repo_name
stringlengths 5
122
| path
stringlengths 3
232
| text
stringlengths 6
1.05M
|
|---|---|---|
proc7ts/hatsy
|
src/http/request/form-decoding.capability.spec.ts
|
import { afterAll, beforeAll, beforeEach, describe, expect, it } from '@jest/globals';
import { silentLogger } from '@proc7ts/logger';
import { Logging } from '../../core';
import { TestHttpServer } from '../../testing';
import { Rendering } from '../render';
import { FormDecoding } from './form-decoding.capability';
describe('FormDecoding', () => {
let server: TestHttpServer;
beforeAll(async () => {
server = await TestHttpServer.start();
});
afterAll(async () => {
await server.stop();
});
beforeEach(() => {
server.handleBy(
{
handleBy(handler) {
return Logging.logBy(silentLogger).for(handler);
},
},
Rendering
.and(FormDecoding)
.for(({ requestBody, renderJson }) => {
renderJson({ request: Array.from(requestBody.entries()) });
}),
);
});
it('processes submitted form', async () => {
const response = await server.post(
'/test',
'param1=value1¶m2=value2',
{
headers: {
'content-type': 'application/x-www-form-urlencoded',
},
},
);
expect(JSON.parse(await response.body())).toEqual({ request: [['param1', 'value1'], ['param2', 'value2']] });
});
it('transforms submitted form', async () => {
server.handleBy(
{
handleBy(handler) {
return Logging.logBy(silentLogger).for(handler);
},
},
Rendering
.and(FormDecoding.withBody(params => Array.from(params.entries())))
.for(({ requestBody, renderJson }) => {
renderJson(requestBody);
}),
);
const response = await server.post(
'/test',
'param1=value1¶m2=value2',
{
headers: {
'content-type': 'application/x-www-form-urlencoded',
},
},
);
expect(JSON.parse(await response.body())).toEqual([['param1', 'value1'], ['param2', 'value2']]);
});
it('processes submitted form with text/plain content type', async () => {
const response = await server.post(
'/test',
'param1=value1¶m2=value2',
{
headers: {
'content-type': 'text/plain',
},
},
);
expect(JSON.parse(await response.body())).toEqual({ request: [['param1', 'value1'], ['param2', 'value2']] });
});
it('processes submitted form without content type', async () => {
const response = await server.post(
'/test',
'param1=value1¶m2=value2',
{
method: 'POST',
},
);
expect(JSON.parse(await response.body())).toEqual({ request: [['param1', 'value1'], ['param2', 'value2']] });
});
it('responds with 415 (Unsupported Media Type) with unsupported request type', async () => {
const response = await server.post(
'/test',
'param1=value1¶m2=value2',
{
headers: { 'content-type': 'application/json' },
},
);
expect(response.statusCode).toBe(415);
expect(await response.body()).toContain('application/x-www-form-urlencoded request expected');
});
});
|
proc7ts/hatsy
|
src/http/request/index.ts
|
export * from './http-forwarding.capability';
export * from './form-decoding.capability';
export * from './json-parsing.capability';
|
proc7ts/hatsy
|
src/core/request-capability.ts
|
import type { RequestHandler } from './request-handler';
/**
* Request processing capability.
*
* Modifies request processing context in a certain way when delegates to handler.
*
* Request processing capabilities could be {@link RequestCapability.combine combined}.
*
* @typeParam TInput - A type of request processing means required in order to apply this capability.
* @typeParam TExt - A type of extension to request processing means this capability applies.
*/
export abstract class RequestCapability<TInput, TExt = object> {
/**
* Builds request capability by the given `provider`.
*
* @typeParam TInput - A type of request processing means required by this provider.
* @typeParam TExt - A type of extension to request processing means this provider applies.
* @param provider - Request processing capability provider.
*
* @returns Request processing capability that call the given `provider` in order to apply.
*/
static of<TInput, TExt>(
this: void,
provider: RequestCapability.Provider<TInput, TExt>,
): RequestCapability<TInput, TExt> {
const capability: RequestCapability<TInput, TExt> = {
for: provider,
and<TNext>(next: RequestCapability<TInput & TExt, TNext>): RequestCapability<TInput, TExt & TNext> {
return RequestCapability.combine(capability, next);
},
};
return capability;
}
/**
* Combines two request processing capabilities.
*
* @typeParam TInput - A type of request processing means expected by the `first` capability.
* @typeParam TExt - A type of request processing means extension applied by the `first` capability.
* @typeParam TNext - A type of request processing means extension applied by the `second` capability.
* @param first - First capability to combine.
* @param second - Second capability to combine. Receives requests modified by the `first` one.
*
* @return Combined request processing capability that applies modifications to request by the `first` capability,
* and then - by the `second` one.
*/
static combine<TInput, TExt, TNext>(
this: void,
first: RequestCapability<TInput, TExt>,
second: RequestCapability<TInput & TExt, TNext>,
): RequestCapability<TInput, TExt & TNext> {
const chain: RequestCapability<TInput, TExt & TNext> = {
for<TMeans extends TInput>(delegate: RequestHandler<TMeans & TExt & TNext>): RequestHandler<TMeans> {
return first.for(second.for(delegate));
},
and<T>(next: RequestCapability<TInput & TExt & TNext, T>): RequestCapability<TInput, TExt & TNext & T> {
return RequestCapability.combine<TInput, TExt & TNext, T>(chain, next);
},
};
return chain;
}
/**
* Provides request processing capability to the given handler.
*
* Builds request processing handler that modifies request and delegates to target `handler`.
*
* @typeParam TMeans - A type of request processing means expected by constructed handler.
* @param handler - Request processing handler that will receive modified request context.
*
* @returns New request processing handler.
*/
abstract for<TMeans extends TInput>(handler: RequestHandler<TMeans & TExt>): RequestHandler<TMeans>;
/**
* Combines this capability with the `next` one.
*
* @typeParam TNext - A type of extension to request processing means applied by `next` capability.
* @param next - Next capability that receives requests modified by this capability.
*
* @return New request processing capability that applies modifications to request by this capability first,
* and then - by the `next` one.
*
* @see RequestCapability.combine
*/
and<TNext>(next: RequestCapability<TInput & TExt, TNext>): RequestCapability<TInput, TExt & TNext> {
return RequestCapability.combine<TInput, TExt, TNext>(this, next);
}
}
export namespace RequestCapability {
/**
* Request processing capability provider signature.
*
* Builds a request processing handler that modifies request and delegates to another one.
*
* @typeParam TInput - A type of request processing means required by this provider.
* @typeParam TExt - A type of extension to request processing means this provider applies.
*/
export type Provider<TInput, TExt = object> =
/**
* @typeParam TMeans - A type of request processing means expected by constructed handler.
*
* @param handler - Request processing handler that will receive modified request context.
*
* @returns New request processing handler.
*/
<TMeans extends TInput>(
this: void,
handler: RequestHandler<TMeans & TExt>,
) => RequestHandler<TMeans>;
}
|
proc7ts/hatsy
|
src/http/render/rendering.capability.spec.ts
|
import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from '@jest/globals';
import { noop } from '@proc7ts/primitives';
import { TextEncoder } from 'node:util';
import { TestHttpServer } from '../../testing';
import { Rendering } from './rendering.capability';
describe('Rendering', () => {
let server: TestHttpServer;
beforeAll(async () => {
server = await TestHttpServer.start();
});
afterAll(async () => {
await server.stop();
});
afterEach(() => {
server.listenBy(noop);
});
describe('renderHtml', () => {
beforeEach(() => {
server.handleBy(Rendering.for(({ renderHtml }) => {
renderHtml('TEST');
}));
});
it('renders HTML', async () => {
const response = await server.get('/test');
const body = await response.body();
expect(body).toBe('TEST');
expect(response.headers['content-type']).toBe('text/html; charset=utf-8');
expect(response.headers['content-length']).toBe('4');
});
it('renders HTML as buffer', async () => {
server.handleBy(Rendering.for(({ renderHtml }) => {
renderHtml(Buffer.from(new TextEncoder().encode('TEST')));
}));
const response = await server.get('/test');
const body = await response.body();
expect(body).toBe('TEST');
expect(response.headers['content-type']).toBe('text/html; charset=utf-8');
expect(response.headers['content-length']).toBe('4');
});
it('is applied once', async () => {
server.handleBy(
Rendering
.and(Rendering)
.and(Rendering)
.for(({ renderHtml }) => {
renderHtml('TEST');
}),
);
const response = await server.get('/test');
const body = await response.body();
expect(body).toBe('TEST');
expect(response.headers['content-type']).toBe('text/html; charset=utf-8');
expect(response.headers['content-length']).toBe('4');
});
it('does not render HTML on HEAD request', async () => {
const response = await server.get('/test', { method: 'head' });
const body = await response.body();
expect(body).toBe('');
expect(response.headers['content-type']).toBe('text/html; charset=utf-8');
expect(response.headers['content-length']).toBe('4');
});
});
describe('renderJson', () => {
beforeEach(() => {
server.handleBy(Rendering.for(({ renderJson }) => {
renderJson('TEST');
}));
});
it('renders JSON', async () => {
const response = await server.get('/test');
const body = await response.body();
expect(body).toBe('"TEST"');
expect(response.headers['content-type']).toBe('application/json; charset=utf-8');
expect(response.headers['content-length']).toBe('6');
});
it('does not render JSON on HEAD request', async () => {
const response = await server.get('/test', { method: 'head' });
const body = await response.body();
expect(body).toBe('');
expect(response.headers['content-type']).toBe('application/json; charset=utf-8');
expect(response.headers['content-length']).toBe('6');
});
});
});
|
proc7ts/hatsy
|
src/core/logging/index.ts
|
export * from './logger.means';
export * from './logging.capability';
export * from './request-logger';
|
proc7ts/hatsy
|
src/http/request/json-parsing.capability.ts
|
import { MIMEType } from '@frontmeans/httongue';
import { asis } from '@proc7ts/primitives';
import {
RequestBodyMeans,
RequestCapability,
RequestContext,
requestExtension,
RequestHandler,
RequestValueTransformer,
} from '../../core';
import { readAll } from '../../impl';
import { HttpError } from '../http-error';
import type { HttpMeans } from '../http.means';
import type { FormDecoding } from './form-decoding.capability';
/**
* @internal
*/
const JSON_MIMES: Readonly<Record<string, number>> = {
[MIMEType.Text]: 1,
[MIMEType.JSON]: 1,
[MIMEType.TextJSON]: 1,
};
/**
* JSON request body parsing capability.
*
* Attempts to parse requested data as JSON, and optionally transforms it to another type.
*
* Responds with 415 (Unsupported Media Type) status code if request has content type specified, and it is not
* `application/json`, `text/json`, or `text/plain`.
*
* Responds with 400 (Bad Request) status code if failed to parse JSON.
*
* @typeParam TInput - Input HTTP request processing means.
* @typeParam TBody - Request body type.
*/
export interface JsonParsing<TInput extends HttpMeans = HttpMeans, TBody = any>
extends RequestCapability<TInput, RequestBodyMeans<TBody>> {
/**
* Configures JSON parsing capability to transform submitted data.
*
* @typeParam TMeans - HTTP request processing means.
* @typeParam TTransformed - Transformed request body type.
* @param transformer - Transformer function.
*
* @returns New JSON parsing capability.
*/
withBody<TMeans extends TInput, TTransformed>(
transformer: RequestValueTransformer<TMeans, any, TTransformed>,
): FormDecoding<TMeans, TTransformed>;
}
/**
* @internal
*/
class JsonParsingCapability<TInput extends HttpMeans, TBody>
extends RequestCapability<TInput, RequestBodyMeans<TBody>>
implements JsonParsing<TInput, TBody> {
constructor(private readonly _transform: RequestValueTransformer<TInput, any, TBody>) {
super();
}
for<TMeans extends TInput>(
handler: RequestHandler<TMeans & RequestBodyMeans<TBody>>,
): RequestHandler<TMeans> {
return async context => {
const { request, next } = context;
const { 'content-type': contentType = MIMEType.Text } = request.headers;
if (!JSON_MIMES[contentType]) {
return Promise.reject(new HttpError(415, { details: `${MIMEType.JSON} request expected` }));
}
let json: any;
const text = await readAll(request);
try {
json = JSON.parse(text);
} catch (e) {
return Promise.reject(new HttpError(400, { details: 'Malformed JSON', reason: e }));
}
return next(handler, requestExtension<TMeans, RequestBodyMeans<TBody>>({
requestBody: await this._transform(json, context as RequestContext<TInput>),
}));
};
}
withBody<TMeans extends TInput, TTransformed>(
transformer: RequestValueTransformer<TMeans, any, TTransformed>,
): FormDecoding<TMeans, TTransformed> {
return new JsonParsingCapability<TMeans, TTransformed>(transformer);
}
}
/**
* JSON request body parsing capability.
*
* Parses request body as JSON.
*/
export const JsonParsing: JsonParsing = new JsonParsingCapability(asis);
|
proc7ts/hatsy
|
src/core/dispatch-error.ts
|
<filename>src/core/dispatch-error.ts
import type { ErrorMeans } from './error.means';
import type { RequestHandler } from './request-handler';
import { requestExtension } from './request-modification';
/**
* Dispatches request processing error.
*
* Processes request with the given handler. If processing fails, processes error with the given `onError` one.
*
* @typeParam TMeans - Request processing means.
* @param onError - Error processing handler.
* @param handler - Request processing handler to process the original request with.
*
* @returns New request processing handler.
*/
export function dispatchError<TMeans>(
onError: RequestHandler<TMeans & ErrorMeans>,
handler: RequestHandler<TMeans>,
): RequestHandler<TMeans> {
return context => context
.next(handler)
.catch(error => context.next<ErrorMeans>(onError, requestExtension({ error })));
}
|
proc7ts/hatsy
|
src/core/request-body.means.ts
|
<gh_stars>1-10
/**
* Request body processing means.
*
* @typeParam TBody - A type of request body.
*/
export interface RequestBodyMeans<TBody> {
/**
* Request body.
*/
readonly requestBody: TBody;
}
|
proc7ts/hatsy
|
src/http/dispatch/dispatch-by-method.handler.spec.ts
|
<gh_stars>1-10
import { afterAll, afterEach, beforeAll, describe, expect, it } from '@jest/globals';
import { silentLogger } from '@proc7ts/logger';
import { noop } from '@proc7ts/primitives';
import { Logging, RequestContext, requestHandler } from '../../core';
import { TestHttpServer } from '../../testing';
import { HttpError } from '../http-error';
import type { HttpMeans } from '../http.means';
import { Rendering, RenderMeans } from '../render';
import { dispatchByMethod } from './dispatch-by-method.handler';
describe('dispatchByName', () => {
let server: TestHttpServer;
beforeAll(async () => {
server = await TestHttpServer.start();
});
afterAll(async () => {
await server.stop();
});
afterEach(() => {
server.handleBy(noop);
});
it('dispatches by method', async () => {
server.handleBy(
Rendering
.for(dispatchByMethod({
search({ renderJson }: RequestContext<HttpMeans & RenderMeans>): void {
renderJson({ response: 'ok' });
},
})),
);
const response = await server.get('/', { method: 'SEARCH' });
expect(response.statusCode).toBe(200);
expect(JSON.parse(await response.body())).toEqual({ response: 'ok' });
});
it('dispatches to HEAD', async () => {
server.handleBy(
Rendering
.for(dispatchByMethod({
head({ renderJson }): void {
renderJson({ response: 'ok' });
},
})),
);
const response = await server.get('/', { method: 'HEAD' });
expect(response.statusCode).toBe(200);
expect(await response.body()).toBe('');
});
it('dispatches to GET on HEAD request', async () => {
server.handleBy(
Rendering
.for(dispatchByMethod({
get({ renderJson }): void {
renderJson({ response: 'ok' });
},
})),
);
const response = await server.get('/', { method: 'HEAD' });
expect(response.statusCode).toBe(200);
expect(await response.body()).toBe('');
});
it('dispatches to GET without method specified', async () => {
server.handleBy(
Rendering.for(requestHandler([
({ request }) => {
delete request.method;
},
dispatchByMethod({
get({ renderJson }): void {
renderJson({ response: 'ok' });
},
}),
])),
);
const response = await server.get('/', { method: 'HEAD' });
expect(response.statusCode).toBe(200);
expect(await response.body()).toBe('');
});
it('does not dispatch without corresponding handler', async () => {
server.handleBy(
{
handleBy(handler) {
return Logging.logBy(silentLogger).for(handler);
},
},
Rendering.for(requestHandler([
dispatchByMethod({
get({ renderJson }): void {
renderJson({ response: 'ok' });
},
}),
() => {
throw new HttpError(404);
},
])),
);
const response = await server.get('/', { method: 'PUT' });
expect(response.statusCode).toBe(404);
});
});
|
proc7ts/hatsy
|
src/core/request-modification.ts
|
/**
* Modification or extension of {@link RequestContext request processing means}.
*
* The properties present here are added to new context potentially replacing the original ones.
*
* @typeParam TMeans - A type of request processing means to modify.
* @typeParam TExt - A type of request processing means extension.
*/
export type RequestModification<TMeans, TExt = object> = {
[K in keyof TMeans]?: TMeans[K] | undefined;
} & {
[K in Exclude<keyof TExt, keyof TMeans>]: TExt[K];
};
/**
* Builds request modification that updates some of the existing properties of request processing means.
*
* This is a helper function to avoid TypeScript limitation. It is a good idea to inline it.
*
* @typeParam TMeans - A type of request processing means to modify.
* @param modification - Partial request modification.
*
* @returns Request modification cast to {@link RequestModification}.
*/
export function requestUpdate<TMeans>(modification: Partial<TMeans>): RequestModification<TMeans> {
return modification;
}
/**
* Builds request modification that adds new properties to request processing means.
*
* This is a helper function to avoid TypeScript limitation. It is a good idea to inline it.
*
* @typeParam TMeans - A type of request processing means to modify.
* @typeParam TExt - A type of request processing means extension.
* @param extension - Request extension containing all the required properties.
*
* @returns Request extension cast to {@link RequestModification}.
*/
export function requestExtension<TMeans, TExt>(extension: TExt): RequestModification<TMeans, TExt> {
return extension;
}
|
proc7ts/hatsy
|
src/http/render/render.means.ts
|
<filename>src/http/render/render.means.ts
/**
* HTTP response body render means.
*
* It is implied that response body is generated by these means only. I.e. nothing is written to `ServerResponse`
* directly.
*
* All `renderXXX` methods write `Content-Length` header. They skip writing content body when request method is `HEAD`.
*/
export interface RenderMeans {
/**
* Renders response body.
*
* @param body - Response body text or Buffer.
* @param encoding - Response body buffer encoding. Ignored for buffer.
*/
renderBody(this: void, body: string | Buffer, encoding?: BufferEncoding): void;
/**
* Renders HTML response body.
*
* Generates content in `UTF-8` encoding and sets `Content-Type: text/html; charset=utf-8` header.
*
* @param html - HTML response text or Buffer.
*/
renderHtml(this: void, html: string | Buffer): void;
/**
* Renders JSON response body.
*
* Generates content in `UTF-8` encoding and sets `Content-Type: application/json; charset=utf-8` header.
*
* @param body - JSON object to stringify.
*/
renderJson(this: void, body: any): void;
}
|
proc7ts/hatsy
|
src/http/index.ts
|
<filename>src/http/index.ts
export * from './dispatch';
export * from './http.means';
export * from './http-config';
export * from './http-error';
export * from './http-listener';
export * from './middleware';
export * from './render';
export * from './request';
export * from './util';
|
Baxterboom/tuna-jsgantt
|
src/viewworker.ts
|
<reponame>Baxterboom/tuna-jsgantt<gh_stars>0
module tuna.gantt {
export class ViewWorker<TArgs, TResult> {
private worker: Worker;
constructor(private file: string, success: (response: TResult) => void, private error?: (error: ErrorEvent) => void) {
this.worker = new Worker(this.file);
this.worker.onmessage = (message) => success(message.data);
if (error) this.worker.onerror = (e) => error(e);
}
send(args: TArgs) {
this.worker.postMessage(args);
return this;
}
stop() {
this.worker.terminate();
}
}
}
|
Baxterboom/tuna-jsgantt
|
src/types/moment.d.ts
|
import * as _moment from '../../node_modules/moment/moment';
export as namespace moment;
export = _moment;
|
Baxterboom/tuna-jsgantt
|
src/parts/parts.ts
|
module tuna.gantt {
import unitOfTime = moment.unitOfTime.DurationConstructor;
export interface IParts extends IViews<ITemplate> {
rows(instance: JSGantt, created?: (item: JQuery) => JQuery): JQuery;
cells(instance: JSGantt, range: IRange, unit: unitOfTime, created?: (item: JQuery) => JQuery): JQuery[];
container(created: (item: JQuery) => JQuery): JQuery;
}
export interface ITemplate {
(instance: JSGantt, range: IRange, created?: (item: JQuery, current: moment.Moment) => JQuery): JQuery[];
}
export const parts: IParts = {
container(created: (item: JQuery) => JQuery) {
const element = $(`<div class="vn-childs"></div>`);
return created ? created(element) : element;
},
rows: (instance: JSGantt, created?: (item: JQuery) => JQuery) => {
const element = $(instance.options.data.Select(s => `<div class="vn-row"></div>`).join("\n"));
return created ? created(element) : element;
},
cells: (instance: JSGantt, range: IRange, unit: unitOfTime, created?: (item: JQuery, current: moment.Moment) => JQuery) => {
const result: JQuery[] = [];
Utils.loopRange(range, unit, current => {
const element = $(`<div class="vn-cell"></div>`);
result.push(created ? created(element, current) : element);
});
return result;
},
days: (instance: JSGantt, range: IRange, created?: (item: JQuery, current: moment.Moment) => JQuery) => {
return Utils.createPart(range, "day", `DD`, created);
},
weeks: (instance: JSGantt, range: IRange, created?: (item: JQuery, current: moment.Moment) => JQuery) => {
return Utils.createPart(range, "week", `[Week] WW`, created);
},
months: (instance: JSGantt, range: IRange, created?: (item: JQuery, current: moment.Moment) => JQuery) => {
return Utils.createPart(range, "month", `MMMM YYYY`, created);
},
years: (instance: JSGantt, range: IRange, created?: (item: JQuery, current: moment.Moment) => JQuery) => {
return Utils.createPart(range, "year", `YYYY`, created);
}
};
}
|
Baxterboom/tuna-jsgantt
|
src/parts/views.ts
|
module tuna.gantt {
export interface IViewTemplate {
onRender(instance: JSGantt): JQuery[];
onMounted?(instance: JSGantt, element: JQuery): void;
}
export const views: IViews<IViewTemplate> = {
days: {
onRender(instance: JSGantt) {
const range = { ...instance.options.range! };
return parts.months(instance, range, (item: JQuery, current: moment.Moment) => {
const range = Utils.createRange(current, "month");
return item.append(parts.weeks(instance, range, (item: JQuery, current: moment.Moment) => {
const range = Utils.createRange(current, "week");
const days = parts.container(item => item.append(parts.days(instance, range))).addClass(`vn-header`);
const columns = parts.container(item => item.append(parts.cells(instance, range, "day"))).addClass(`vn-columns`);
return item.append([days, columns]).addClass(`vn-header`);
})).addClass(`vn-header`);
});
}
},
weeks: {
onRender(instance: JSGantt) {
const range = { ...instance.options.range! };
return parts.months(instance, range, (item: JQuery, current: moment.Moment) => {
const range = Utils.createRange(current, "month");
return item.append(parts.weeks(instance, range));
});
}
},
months: {
onRender(instance: JSGantt) {
const range = { ...instance.options.range! };
return parts.years(instance, range, (item: JQuery, current: moment.Moment) => {
const range = Utils.createRange(current, "year");
return item.append(parts.months(instance, range));
});
}
},
years: {
onRender(instance: JSGantt) {
const range = { ...instance.options.range! };
return parts.years(instance, range);
}
}
};
}
|
Baxterboom/tuna-jsgantt
|
src/workers/views/view.day.ts
|
module tuna.gantt {
export interface IDayViewMessageEvent<T> extends MessageEvent {
data: T;
}
export interface IDayViewMessageEventArguments {
end: number;
start: number;
count: number;
origin: string;
}
importScripts("https://cdnjs.cloudflare.com/ajax/libs/moment.js/2.24.0/moment.js");
onmessage = function (e: IDayViewMessageEvent<IDayViewMessageEventArguments>) {
console.time("view.day.worker");
const data = e.data;
const end = moment(data.end).startOf("day");
const start = moment(data.start).startOf("day");
const count = data.count;
//@ts-ignore
postMessage(createElementHtml());
function createElementHtml() {
const result: string[] = [];
result.push(`<div class="vn-row">`);
while (start <= end) {
//result.push(`<div class="vn-day">${start.format("D")}</div>`);
result.push(`<div class="vn-day"></div>`);
start.add(1, "day");
}
result.push("</div>");
return repeat(result.join(""), count);
}
function repeat(text: string, count: number) {
return count < 1 ? '' : new Array(count).join(text);
}
console.timeEnd("view.day.worker");
};
}
|
Baxterboom/tuna-jsgantt
|
src/utils.ts
|
<gh_stars>0
module tuna.gantt {
export class Utils {
static loopRange(range: IRange, unit: moment.unitOfTime.DurationConstructor, callback: (current: moment.Moment) => void) {
const end = range.end.endOf("day");
const current = moment(range.start).startOf("day");
while (current <= end) {
callback(current);
current.add(1, unit);
}
}
static createPart(range: IRange, unit: moment.unitOfTime.DurationConstructor, displayFormat?: string, created?: (item: JQuery, current: moment.Moment) => JQuery): JQuery[] {
const result: JQuery[] = [];
Utils.loopRange(range, unit, current => {
const titleHtml = displayFormat ? `<div class="vn-title">${current.format(displayFormat)}</div>` : ``;
const element = $(`<div class="vn-${unit}">${titleHtml}</div>`);
result.push(created ? created(element, current) : element);
});
return result;
}
static createRange(date: moment.Moment, unit: moment.unitOfTime.DurationConstructor) {
return { start: date.clone().startOf(unit), end: date.clone().endOf(unit) };
}
}
}
|
Baxterboom/tuna-jsgantt
|
src/index.ts
|
<reponame>Baxterboom/tuna-jsgantt
module tuna.gantt {
export type View = keyof IViews;
export interface IOptions {
data: ITask[];
view?: View
views?: View[];
range?: IRange;
}
export interface IRange {
end: moment.Moment;
start: moment.Moment;
}
export interface ITask<TCustom = any> {
id: string | number;
data?: TCustom;
items: ITaskItem[]
onClick?(task: ITask): boolean;
}
export interface ITaskItem<TCustom = any> {
id: string | number;
data?: TCustom;
range: IRange;
onClick?(item: ITaskItem): boolean;
}
export interface IViews<T = ITemplate> {
days: T;
weeks: T;
months: T;
years: T;
}
}
|
Baxterboom/tuna-jsgantt
|
dist/tuna-jsgantt.d.ts
|
/// <reference types="jquery" />
/// <reference types="moment" />
declare module tuna.gantt {
class JSGantt {
options: IOptions;
private element;
private elements;
constructor(element: JQuery | string, options?: IOptions);
update(options: IOptions): void;
render(view?: View): void;
private setupRows;
private setupRange;
}
}
declare module tuna.gantt {
type View = keyof IViews;
interface IOptions {
data: ITask[];
view?: View;
views?: View[];
range?: IRange;
}
interface IRange {
end: moment.Moment;
start: moment.Moment;
}
interface ITask<TCustom = any> {
id: string | number;
data?: TCustom;
items: ITaskItem[];
onClick?(task: ITask): boolean;
}
interface ITaskItem<TCustom = any> {
id: string | number;
data?: TCustom;
range: IRange;
onClick?(item: ITaskItem): boolean;
}
interface IViews<T = ITemplate> {
days: T;
weeks: T;
months: T;
}
}
declare module tuna.gantt {
class Utils {
static loopRange(range: IRange, unit: moment.unitOfTime.DurationConstructor, callback: (current: moment.Moment) => void): void;
static createPart(range: IRange, unit: moment.unitOfTime.DurationConstructor, displayFormat: string, created?: (current: moment.Moment) => string[]): string[];
static createRange(date: moment.Moment, unit: moment.unitOfTime.DurationConstructor): {
start: moment.Moment;
end: moment.Moment;
};
}
}
declare module tuna.gantt {
class ViewWorker<TArgs, TResult> {
private file;
private error?;
private worker;
constructor(file: string, success: (response: TResult) => void, error?: ((error: ErrorEvent) => void) | undefined);
send(args: TArgs): this;
stop(): void;
}
}
declare module tuna.gantt {
interface IParts extends IViews<ITemplate> {
row: ITemplate;
}
interface ITemplate {
onRender(instance: JSGantt, range: IRange, created?: (range: moment.Moment) => string[]): string[];
}
const parts: IParts;
}
declare module tuna.gantt {
interface IViewTemplate {
onRender(instance: JSGantt): string;
onMounted?(instance: JSGantt, element: JQuery): void;
}
const views: IViews<IViewTemplate>;
}
|
Baxterboom/tuna-jsgantt
|
dist/workers/view.day.d.ts
|
<reponame>Baxterboom/tuna-jsgantt<gh_stars>0
declare module tuna.gantt {
interface IDayViewMessageEvent<T> extends MessageEvent {
data: T;
}
interface IDayViewMessageEventArguments {
end: number;
start: number;
count: number;
origin: string;
}
}
|
Baxterboom/tuna-jsgantt
|
src/gantt.ts
|
module tuna.gantt {
const defaults = Object.freeze<IOptions>({
data: [],
view: "days",
views: ["days", "weeks", "months"]
});
interface IElements {
head: JQuery;
body: JQuery;
}
export class JSGantt {
private element: JQuery;
private elements: IElements;
private days = new ViewWorker<IDayViewMessageEventArguments, string>(
"dist/workers/view.day.js",
result => this.elements.body.append(result),
error => console.error(error));
constructor(element: JQuery | string, public options: IOptions = defaults) {
this.element = $(element as string);
this.element.data("JSGantt", this);
this.element.addClass("vn-gantt");
this.element.append(`
<div class="vn-root ${options.view}">
<div class="vn-head"></div>
<div class="vn-body"></div>
</div>
`);
this.elements = {
head: this.element.find(".vn-head"),
body: this.element.find(".vn-body")
};
this.update(options);
// this.createDummyData();
}
public update(options: IOptions) {
this.options = {
...defaults,
...this.options,
...options
};
this.render(this.options.view);
}
public render(view: View = this.options.view!) {
console.time("render " + view);
this.setupRange(this.options);
const template = views[view];
if (!template) console.warn(`JSGantt - view ${view} does not exist`);
const element = template.onRender(this);
this.elements.body.empty()
this.elements.head.empty().append(element);
if (template.onMounted) template.onMounted(this, this.elements.head);
this.setupRows();
this.setupEvents();
console.timeEnd("render " + view);
}
private setupEvents() {
const views: View[] = ["days", "weeks", "months", "years"];
views.forEach((name, index) => {
const target = this.elements.head.find(".vn-" + name.slice(0, -1));
target.mousedown(event => {
const target = event.which == 1 ? index - 1 : index;
this.render(views[target]);
});
})
}
private setupRows() {
const range = this.options.range;
this.days.send({ count: this.options.data.length, origin: document.location.origin, start: range!.start.valueOf(), end: range!.end.valueOf() });
}
private setupRange(options: IOptions) {
if (options.range) return;
options.range = {
end: this.options.data.SelectMany(s => s.items.Select(r => r.range.end)).Max() || moment().add(4, "year"),
start: this.options.data.SelectMany(s => s.items.Select(r => r.range.start)).Min() || moment()
};
}
}
}
|
atymic/soketi
|
tests/presence.test.ts
|
import { Server } from './../src/server';
import { Utils } from './utils';
jest.retryTimes(2);
describe('presence channel test', () => {
beforeEach(() => {
jest.resetModules();
return Utils.waitForPortsToFreeUp();
});
afterEach(() => {
return Utils.flushServers();
});
test('connects to presence channel', done => {
Utils.newServer({}, (server: Server) => {
let user = {
user_id: 1,
user_info: {
id: 1,
name: 'John',
},
};
let client = Utils.newClientForPresenceUser(user);
let backend = Utils.newBackend();
let channelName = `presence-${Utils.randomChannelName()}`;
client.connection.bind('connected', () => {
let channel = client.subscribe(channelName);
channel.bind('greeting', (e) => {
expect(e.message).toBe('hello');
client.disconnect();
done();
});
channel.bind('pusher:subscription_succeeded', (data) => {
expect(data.count).toBe(1);
expect(data.me.id).toBe(1);
expect(data.members['1'].id).toBe(1);
expect(data.me.info.name).toBe('John');
Utils.sendEventToChannel(backend, channelName, 'greeting', { message: 'hello' })
.catch(error => {
throw new Error(error);
});
});
});
});
});
test('handles joins and leaves', done => {
Utils.newServer({}, (server: Server) => {
let john = {
user_id: 1,
user_info: {
id: 1,
name: 'John',
},
};
let alice = {
user_id: 2,
user_info: {
id: 2,
name: 'Alice',
},
};
let johnClient = Utils.newClientForPresenceUser(john);
let channelName = `presence-${Utils.randomChannelName()}`;
johnClient.connection.bind('connected', () => {
let johnChannel = johnClient.subscribe(channelName);
johnChannel.bind('pusher:subscription_succeeded', (data) => {
expect(data.count).toBe(1);
expect(data.me.id).toBe(1);
expect(data.members['1'].id).toBe(1);
expect(data.me.info.name).toBe('John');
let aliceClient = Utils.newClientForPresenceUser(alice);
aliceClient.connection.bind('connected', () => {
let aliceChannel = aliceClient.subscribe(channelName);
aliceChannel.bind('pusher:subscription_succeeded', (data) => {
expect(data.count).toBe(2);
expect(data.me.id).toBe(2);
expect(data.members['1'].id).toBe(1);
expect(data.members['2'].id).toBe(2);
expect(data.me.info.name).toBe('Alice');
aliceClient.disconnect();
});
});
});
johnChannel.bind('pusher:member_added', data => {
expect(data.id).toBe(2);
expect(data.info.name).toBe('Alice');
});
johnChannel.bind('pusher:member_removed', data => {
expect(data.id).toBe(2);
expect(data.info.name).toBe('Alice');
done();
});
});
});
});
test('cannot connect to presence channel with wrong authentication', done => {
Utils.newServer({}, (server: Server) => {
let user = {
user_id: 1,
user_info: {
id: 1,
name: 'John',
},
};
let client = Utils.newClientForPresenceUser(user, {
authorizer: (channel, options) => ({
authorize: (socketId, callback) => {
callback(false, {
auth: 'incorrect_token',
channel_data: JSON.stringify(user),
});
},
}),
});
let channelName = `presence-${Utils.randomChannelName()}`;
client.connection.bind('message', ({ event, channel, data }) => {
if (event === 'pusher:subscription_error' && channel === channelName) {
expect(data.type).toBe('AuthError');
expect(data.status).toBe(401);
done();
}
});
client.connection.bind('connected', () => {
client.subscribe(channelName);
});
});
});
test('connects and disconnects to presence channel and does not leak memory', done => {
Utils.newServer({}, (server: Server) => {
let user = {
user_id: 1,
user_info: {
id: 1,
name: 'John',
},
};
let client = Utils.newClientForPresenceUser(user);
let backend = Utils.newBackend();
let channelName = `presence-${Utils.randomChannelName()}`;
client.connection.bind('disconnected', () => {
Utils.wait(3000).then(() => {
let namespace = server.adapter.getNamespace('app-id');
expect(namespace.sockets.size).toBe(0);
expect(namespace.channels.size).toBe(0);
done();
});
});
client.connection.bind('connected', () => {
let channel = client.subscribe(channelName);
channel.bind('greeting', (e) => {
expect(e.message).toBe('hello');
client.unsubscribe(channelName);
Utils.wait(3000).then(() => {
let namespace = server.adapter.getNamespace('app-id');
let socket = namespace.sockets.get(namespace.sockets.keys().next().value);
expect(namespace.channels.size).toBe(0);
expect(namespace.sockets.size).toBe(1);
expect(socket.subscribedChannels.size).toBe(0);
expect(socket.presence.size).toBe(0);
client.disconnect();
});
});
channel.bind('pusher:subscription_succeeded', (data) => {
Utils.sendEventToChannel(backend, channelName, 'greeting', { message: 'hello' });
});
});
});
});
test('sudden close connection in presence channel and does not leak memory', done => {
Utils.newServer({}, (server: Server) => {
let user = {
user_id: 1,
user_info: {
id: 1,
name: 'John',
},
};
let client = Utils.newClientForPresenceUser(user);
let backend = Utils.newBackend();
let channelName = `presence-${Utils.randomChannelName()}`;
client.connection.bind('disconnected', () => {
Utils.wait(3000).then(() => {
let namespace = server.adapter.getNamespace('app-id');
expect(namespace.sockets.size).toBe(0);
expect(namespace.channels.size).toBe(0);
done();
});
});
client.connection.bind('connected', () => {
let channel = client.subscribe(channelName);
channel.bind('greeting', (e) => {
expect(e.message).toBe('hello');
client.disconnect();
});
channel.bind('pusher:subscription_succeeded', (data) => {
Utils.sendEventToChannel(backend, channelName, 'greeting', { message: 'hello' });
});
});
});
});
test('connecting to the channel twice with same user does not trigger member_added twice', done => {
Utils.newServer({}, (server: Server) => {
let john = {
user_id: 1,
user_info: {
id: 1,
name: 'John',
},
};
let alice = {
user_id: 2,
user_info: {
id: 2,
name: 'Alice',
},
};
let johnClient = Utils.newClientForPresenceUser(john);
let channelName = `presence-${Utils.randomChannelName()}`;
johnClient.connection.bind('connected', () => {
let johnChannel = johnClient.subscribe(channelName);
johnChannel.bind('pusher:subscription_succeeded', (data) => {
let aliceClient = Utils.newClientForPresenceUser(alice);
aliceClient.connection.bind('connected', () => {
let aliceChannel = aliceClient.subscribe(channelName);
aliceChannel.bind('pusher:member_added', data => {
throw new Error('Did not expect John to be added again.');
});
aliceChannel.bind('pusher:member_removed', data => {
server.adapter.getChannelMembers('app-id', channelName).then(members => {
if (members.size === 1) {
done();
} else {
throw new Error('The member_removed got triggered but John did not left.');
}
});
});
aliceChannel.bind('pusher:subscription_succeeded', (data) => {
expect(data.count).toBe(2);
let anotherJohnClient = Utils.newClientForPresenceUser(john);
anotherJohnClient.connection.bind('connected', () => {
let anotherJohnChannel = anotherJohnClient.subscribe(channelName);
anotherJohnChannel.bind('pusher:subscription_succeeded', (data) => {
expect(data.count).toBe(2);
anotherJohnClient.disconnect();
johnClient.disconnect();
});
});
});
});
});
});
});
});
});
|
atymic/soketi
|
src/namespace.ts
|
import { PresenceMember, PresenceMemberInfo } from './channels/presence-channel-manager';
import { WebSocket } from 'uWebSockets.js';
export class Namespace {
/**
* The list of channel connections for the current app.
*/
public channels: Map<string, Set<string>> = new Map();
/**
* The list of sockets connected to the namespace.
*/
public sockets: Map<string, WebSocket> = new Map();
/**
* Initialize the namespace for an app.
*/
constructor(protected appId: string) {
//
}
/**
* Get all sockets from this namespace.
*/
getSockets(): Promise<Map<string, WebSocket>> {
return Promise.resolve(this.sockets);
}
/**
* Add a new socket to the namespace.
*/
addSocket(ws: WebSocket): Promise<boolean> {
return new Promise(resolve => {
this.sockets.set(ws.id, ws);
resolve(true);
});
}
/**
* Remove a socket from the namespace.
*/
async removeSocket(wsId: string): Promise<boolean> {
for (let channel of this.channels.keys()) {
this.removeFromChannel(wsId, channel);
}
return this.sockets.delete(wsId);
}
/**
* Add a socket ID to the channel identifier.
* Return the total number of connections after the connection.
*/
addToChannel(ws: WebSocket, channel: string): Promise<number> {
return new Promise(resolve => {
if (!this.channels.has(channel)) {
this.channels.set(channel, new Set);
}
this.channels.get(channel).add(ws.id);
resolve(this.channels.get(channel).size);
});
}
/**
* Remove a socket ID from the channel identifier.
* Return the total number of connections remaining to the channel.
*/
async removeFromChannel(wsId: string, channel: string): Promise<number> {
return new Promise(resolve => {
if (this.channels.has(channel)) {
this.channels.get(channel).delete(wsId);
if (this.channels.get(channel).size === 0) {
this.channels.delete(channel);
}
}
resolve(this.channels.has(channel) ? this.channels.get(channel).size : 0);
});
}
/**
* Check if a socket ID is joined to the channel.
*/
isInChannel(wsId: string, channel: string): Promise<boolean> {
return new Promise(resolve => {
if (!this.channels.has(channel)) {
return resolve(false);
}
resolve(this.channels.get(channel).has(wsId));
});
}
/**
* Get the list of channels with the websocket IDs.
*/
getChannels(): Promise<Map<string, Set<string>>> {
return Promise.resolve(this.channels);
}
/**
* Get all the channel sockets associated with this namespace.
*/
getChannelSockets(channel: string): Promise<Map<string, WebSocket>> {
return new Promise(resolve => {
if (!this.channels.has(channel)) {
return resolve(new Map<string, WebSocket>());
}
let wsIds = this.channels.get(channel);
resolve(
Array.from(wsIds).reduce((sockets, wsId) => {
if (!this.sockets.has(wsId)) {
return sockets;
}
return sockets.set(wsId, this.sockets.get(wsId));
}, new Map<string, WebSocket>())
);
});
}
/**
* Get a given presence channel's members.
*/
getChannelMembers(channel: string): Promise<Map<string, PresenceMemberInfo>> {
return this.getChannelSockets(channel).then(sockets => {
return Array.from(sockets).reduce((members, [wsId, ws]) => {
let member: PresenceMember = ws.presence.get(channel);
if (member) {
members.set(member.user_id as string, member.user_info);
}
return members;
}, new Map<string, PresenceMemberInfo>());
});
}
}
|
atymic/soketi
|
src/cli/index.ts
|
<reponame>atymic/soketi
import { Cli } from './cli';
let yargs = require('yargs')
.usage('Usage: soketi <command> [options]')
.command('start', 'Start the server.', yargs => {
return yargs.option('config', { describe: 'The path for the config file. (optional)'});
}, (argv) => Cli.start(argv))
.demandCommand(1, 'Please provide a valid command.')
.help('help')
.alias('help', 'h');
yargs.$0 = '';
let argv = yargs.argv;
|
atymic/soketi
|
src/channels/index.ts
|
<filename>src/channels/index.ts
export * from './encrypted-private-channel-manager';
export * from './presence-channel-manager';
export * from './private-channel-manager';
export * from './public-channel-manager';
|
atymic/soketi
|
src/channels/private-channel-manager.ts
|
<gh_stars>100-1000
import { App } from '../app';
import { JoinResponse, PublicChannelManager } from './public-channel-manager';
import { PusherMessage } from '../message';
import { WebSocket } from 'uWebSockets.js';
const Pusher = require('pusher');
export class PrivateChannelManager extends PublicChannelManager {
/**
* Join the connection to the channel.
*/
join(ws: WebSocket, channel: string, message?: PusherMessage): Promise<JoinResponse> {
let passedSignature = message?.data?.auth;
return this.signatureIsValid(ws.app, ws.id, message, passedSignature).then(isValid => {
if (!isValid) {
return {
ws,
success: false,
errorCode: 4009,
errorMessage: 'The connection is unauthorized.',
authError: true,
type: 'AuthError',
};
}
return super.join(ws, channel, message);
});
}
/**
* Check is an incoming connection can subscribe.
*/
protected signatureIsValid(app: App, socketId: string, message: PusherMessage, signatureToCheck: string): Promise<boolean> {
return this.getExpectedSignature(app, socketId, message).then(expectedSignature => {
return signatureToCheck === expectedSignature;
});
}
/**
* Get the signed token from the given message, by the Socket.
*/
protected getExpectedSignature(app: App, socketId: string, message: PusherMessage): Promise<string> {
return new Promise(resolve => {
let token = new Pusher.Token(app.key, app.secret);
resolve(
app.key + ':' + token.sign(this.getDataToSignForSignature(socketId, message))
);
});
}
/**
* Get the data to sign for the token for specific channel.
*/
protected getDataToSignForSignature(socketId: string, message: PusherMessage): string {
return `${socketId}:${message.data.channel}`;
}
}
|
atymic/soketi
|
src/queues/redis-queue-driver.ts
|
import async from 'async';
import { Queue, Worker, QueueScheduler } from 'bullmq'
import { QueueInterface } from './queue-interface';
import { Server } from '../server';
const Redis = require('ioredis');
interface QueueWithWorker {
queue: Queue;
worker: Worker;
scheduler: QueueScheduler;
}
export class RedisQueueDriver implements QueueInterface {
/**
* The queues with workers list.
*/
protected queueWithWorker: Map<string, QueueWithWorker> = new Map();
/**
* Initialize the Redis Queue Driver.
*/
constructor(protected server: Server) {
//
}
/**
* Add a new event with data to queue.
*/
addToQueue(queueName: string, data: any = {}): Promise<void> {
return new Promise(resolve => {
let queueWithWorker = this.queueWithWorker.get(queueName);
if (!queueWithWorker) {
return resolve();
}
queueWithWorker.queue.add('webhook', data).then(() => resolve());
});
}
/**
* Register the code to run when handing the queue.
*/
processQueue(queueName: string, callback: CallableFunction): Promise<void> {
return new Promise(resolve => {
if (!this.queueWithWorker.has(queueName)) {
const connection = new Redis({
maxRetriesPerRequest: null,
enableReadyCheck: false,
...this.server.options.database.redis,
// We set the key prefix on the queue, worker and scheduler instead of on the connection itself
keyPrefix: undefined,
});
// We remove a trailing `:` from the prefix because BullMQ adds that already
const prefix = this.server.options.database.redis.keyPrefix.replace(/:$/, '');
const sharedOptions = { prefix, connection };
this.queueWithWorker.set(queueName, {
queue: new Queue(queueName, {
...sharedOptions,
defaultJobOptions: {
attempts: 6,
backoff: {
type: 'exponential',
delay: 1000,
},
removeOnComplete: true,
removeOnFail: true,
},
}),
// TODO: Sandbox the worker? https://docs.bullmq.io/guide/workers/sandboxed-processors
worker: new Worker(queueName, callback as any, {
...sharedOptions,
concurrency: this.server.options.queue.redis.concurrency,
}),
// TODO: Seperate this from the queue with worker when multipe workers are supported.
// A single scheduler per queue is needed: https://docs.bullmq.io/guide/queuescheduler
scheduler: new QueueScheduler(queueName, sharedOptions),
});
}
resolve();
});
}
/**
* Clear the queues for a graceful shutdown.
*/
clear(): Promise<void> {
return async.each([...this.queueWithWorker], ([queueName, { queue, worker, scheduler }]: [string, QueueWithWorker], callback) => {
scheduler.close().then(() => {
worker.close().then(() => callback());
});
});
}
}
|
atymic/soketi
|
src/index.ts
|
export * from './app';
export * from './http-handler';
export * from './job';
export * from './log';
export * from './namespace';
export * from './options';
export * from './server';
export * from './utils';
export * from './webhook-sender';
export * from './ws-handler';
|
atymic/soketi
|
src/queues/queue-interface.ts
|
<reponame>atymic/soketi<gh_stars>100-1000
export interface QueueInterface {
/**
* The Queue driver.
*/
driver?: QueueInterface;
/**
* Add a new event with data to queue.
*/
addToQueue(queueName: string, data?: any): Promise<void>;
/**
* Register the code to run when handing the queue.
*/
processQueue(queueName: string, callback: CallableFunction): Promise<void>;
/**
* Clear the queues for a graceful shutdown.
*/
clear(): Promise<void>;
}
|
atymic/soketi
|
src/utils.ts
|
export class Utils {
/**
* Allowed client events patterns.
*
* @type {string[]}
*/
protected static _clientEventPatterns: string[] = [
'client-*',
];
/**
* Channels and patters for private channels.
*
* @type {string[]}
*/
protected static _privateChannelPatterns: string[] = [
'private-*',
'private-encrypted-*',
'presence-*',
];
/**
* Get the amount of bytes from given parameters.
*/
static dataToBytes(...data: any): number {
return data.reduce((totalBytes, element) => {
element = typeof element === 'string' ? element : JSON.stringify(element);
try {
return totalBytes += Buffer.byteLength(element, 'utf8');
} catch (e) {
return totalBytes;
}
}, 0);
}
/**
* Get the amount of kilobytes from given parameters.
*/
static dataToKilobytes(...data: any): number {
return this.dataToBytes(...data) / 1024;
}
/**
* Get the amount of megabytes from given parameters.
*/
static dataToMegabytes(...data: any): number {
return this.dataToKilobytes(...data) / 1024;
}
/**
* Check if the given channel name is private.
*/
static isPrivateChannel(channel: string): boolean {
let isPrivate = false;
this._privateChannelPatterns.forEach(pattern => {
let regex = new RegExp(pattern.replace('*', '.*'));
if (regex.test(channel)) {
isPrivate = true;
}
});
return isPrivate;
}
/**
* Check if the given channel name is a presence channel.
*/
static isPresenceChannel(channel: string): boolean {
return channel.lastIndexOf('presence-', 0) === 0;
}
/**
* Check if the given channel name is a encrypted private channel.
*/
static isEncryptedPrivateChannel(channel: string): boolean {
return channel.lastIndexOf('private-encrypted-', 0) === 0;
}
/**
* Check if client is a client event.
*/
static isClientEvent(event: string): boolean {
let isClientEvent = false;
this._clientEventPatterns.forEach(pattern => {
let regex = new RegExp(pattern.replace('*', '.*'));
if (regex.test(event)) {
isClientEvent = true;
}
});
return isClientEvent;
}
}
|
atymic/soketi
|
src/job.ts
|
<gh_stars>100-1000
import { v4 as uuidv4 } from 'uuid';
export class Job {
/**
* Create a new job instance.
*/
constructor(public id: string = uuidv4(), public data: { [key: string]: any; } = {}) {
//
}
}
|
atymic/soketi
|
src/log.ts
|
<reponame>atymic/soketi
const colors = require('colors');
export class Log {
static infoTitle(message: any): void {
console.log(colors.bold.black.bgCyan(message));
}
static successTitle(message: any): void {
console.log(colors.bold.black.bgGreen(message));
}
static errorTitle(message: any): void {
console.log(colors.bold.black.bgRed(this.prefixWithTime(message)));
}
static warningTitle(message: any): void {
console.log(colors.bold.black.bgYellow(this.prefixWithTime(message)));
}
static clusterTitle(message: any): void {
console.log(colors.bold.yellow.bgMagenta(this.prefixWithTime(message)));
}
static httpTitle(message: any): void {
this.infoTitle(this.prefixWithTime(message));
}
static discoverTitle(message: any): void {
console.log(colors.bold.gray.bgBrightCyan(this.prefixWithTime(message)));
}
static websocketTitle(message: any): void {
this.successTitle(this.prefixWithTime(message));
}
static webhookSenderTitle(message: any): void {
console.log(colors.bold.blue.bgWhite(this.prefixWithTime(message)));
}
static info(message: any): void {
console.log(colors.cyan(message));
}
static success(message: any): void {
console.log(colors.green(message));
}
static error(message: any): void {
console.log(colors.red(message));
}
static warning(message: any): void {
console.log(colors.yellow(message));
}
static cluster(message: any): void {
console.log(colors.bold.magenta(message));
}
static http(message: any): void {
this.info(message);
}
static discover(message: any): void {
console.log(colors.bold.brightCyan(message));
}
static websocket(message: any): void {
this.success(message);
}
static webhookSender(message: any): void {
console.log(colors.bold.white(message));
}
protected static prefixWithTime(message: any): any {
if (typeof message === 'string') {
return '[' + (new Date).toString() + '] ' + message;
}
return message;
}
}
|
atymic/soketi
|
src/app-managers/base-app-manager.ts
|
<filename>src/app-managers/base-app-manager.ts
import { App } from '../app';
import { AppManagerInterface } from './app-manager-interface';
export class BaseAppManager implements AppManagerInterface {
/**
* Find an app by given ID.
*/
findById(id: string): Promise<App|null> {
return Promise.resolve(null);
}
/**
* Find an app by given key.
*/
findByKey(key: string): Promise<App|null> {
return Promise.resolve(null);
}
/**
* Get the app secret by ID.
*/
getAppSecret(id: string): Promise<string|null> {
return this.findById(id).then(app => {
return app
? app.secret
: null;
});
}
}
|
atymic/soketi
|
tests/ws.test.ts
|
import { Server } from './../src/server';
import { Utils } from './utils';
jest.retryTimes(2);
describe('ws test', () => {
beforeEach(() => {
jest.resetModules();
return Utils.waitForPortsToFreeUp();
});
afterEach(() => {
return Utils.flushServers();
});
Utils.shouldRun(Utils.appManagerIs('array'))('client events', done => {
Utils.newServer({ 'appManager.array.apps.0.enableClientMessages': true }, (server: Server) => {
let client1 = Utils.newClientForPrivateChannel();
let channelName = `private-${Utils.randomChannelName()}`;
client1.connection.bind('connected', () => {
client1.connection.bind('message', ({ event, channel, data }) => {
if (event === 'client-greeting' && channel === channelName) {
expect(data.message).toBe('hello');
done();
}
});
let channel = client1.subscribe(channelName);
channel.bind('pusher:subscription_succeeded', () => {
let client2 = Utils.newClientForPrivateChannel();
client2.connection.bind('connected', () => {
let channel = client2.subscribe(channelName);
channel.bind('pusher:subscription_succeeded', () => {
channel.trigger('client-greeting', {
message: 'hello',
});
});
});
});
});
});
});
Utils.shouldRun(Utils.appManagerIs('array'))('client events dont get emitted when client messaging is disabled', done => {
Utils.newServer({ 'appManager.array.apps.0.enableClientMessages': false }, (server: Server) => {
let client1 = Utils.newClientForPrivateChannel();
let channelName = `private-${Utils.randomChannelName()}`;
client1.connection.bind('connected', () => {
client1.connection.bind('message', ({ event, channel, data }) => {
if (event === 'client-greeting' && channel === channelName) {
throw new Error('The message was actually sent.');
}
});
let channel = client1.subscribe(channelName);
channel.bind('pusher:subscription_succeeded', () => {
let client2 = Utils.newClientForPrivateChannel({});
client2.connection.bind('connected', () => {
let channel = client2.subscribe(channelName);
channel.bind('pusher:subscription_succeeded', () => {
channel.bind('pusher:error', (error) => {
expect(error.code).toBe(4301);
done();
});
channel.trigger('client-greeting', {
message: 'hello',
});
});
});
});
});
});
});
Utils.shouldRun(Utils.appManagerIs('array'))('client events dont get emitted when event name is big', done => {
Utils.newServer({ 'appManager.array.apps.0.enableClientMessages': true, 'eventLimits.maxNameLength': 25 }, (server: Server) => {
let client1 = Utils.newClientForPrivateChannel();
let channelName = `private-${Utils.randomChannelName()}`;
let eventName = 'client-a8hsuNFXUhfStiWE02R'; // 26 characters
client1.connection.bind('connected', () => {
client1.connection.bind('message', ({ event, channel, data }) => {
if (event === eventName && channel === channelName) {
throw new Error('The message was actually sent.');
}
});
let channel = client1.subscribe(channelName);
channel.bind('pusher:subscription_succeeded', () => {
let client2 = Utils.newClientForPrivateChannel({});
client2.connection.bind('connected', () => {
let channel = client2.subscribe(channelName);
channel.bind('pusher:subscription_succeeded', () => {
channel.bind('pusher:error', (error) => {
expect(error.code).toBe(4301);
done();
});
channel.trigger(eventName, {
message: 'hello',
});
});
});
});
});
});
});
Utils.shouldRun(Utils.appManagerIs('array'))('client events dont get emitted when event payload is big', done => {
Utils.newServer({ 'appManager.array.apps.0.enableClientMessages': true, 'eventLimits.maxPayloadInKb': 1/1024/1024 }, (server: Server) => {
let client1 = Utils.newClientForPrivateChannel();
let channelName = `private-${Utils.randomChannelName()}`;
client1.connection.bind('connected', () => {
client1.connection.bind('message', ({ event, channel, data }) => {
if (event === 'client-greeting' && channel === channelName) {
throw new Error('The message was actually sent.');
}
});
let channel = client1.subscribe(channelName);
channel.bind('pusher:subscription_succeeded', () => {
let client2 = Utils.newClientForPrivateChannel({});
client2.connection.bind('connected', () => {
let channel = client2.subscribe(channelName);
channel.bind('pusher:subscription_succeeded', () => {
channel.bind('pusher:error', (error) => {
expect(error.code).toBe(4301);
done();
});
channel.trigger('client-greeting', {
message: 'hello',
});
});
});
});
});
});
});
test('cannot connect using invalid app key', done => {
Utils.newServer({}, (server: Server) => {
let client = Utils.newClient({}, 6001, 'invalid-key', false);
client.connection.bind('state_change', ({ current }) => {
if (['unavailable', 'failed', 'disconnected'].includes(current)) {
done();
} else {
throw new Error(`${current} is not an expected state.`);
}
});
});
});
Utils.shouldRun(Utils.appManagerIs('array'))('throw over quota error if reached connection limit', done => {
Utils.newServer({ 'appManager.array.apps.0.maxConnections': 1 }, (server: Server) => {
let client1 = Utils.newClient({}, 6001, 'app-key', false);
client1.connection.bind('connected', () => {
let client2 = Utils.newClient({}, 6001, 'app-key', false);
client2.connection.bind('state_change', ({ current }) => {
if (['unavailable', 'failed', 'disconnected'].includes(current)) {
done();
} else {
throw new Error(`${current} is not an expected state.`);
}
});
});
});
});
Utils.shouldRun(Utils.appManagerIs('array'))('throw invalid app error if app is deactivated', done => {
Utils.newServer({ 'appManager.array.apps.0.enabled': false }, (server: Server) => {
let client = Utils.newClient();
client.connection.bind('state_change', ({ current }) => {
if (['unavailable', 'failed', 'disconnected'].includes(current)) {
done();
} else {
throw new Error(`${current} is not an expected state.`);
}
});
});
});
test('should check for channelLimits.maxNameLength', done => {
Utils.newServer({ 'channelLimits.maxNameLength': 25 }, (server: Server) => {
let client = Utils.newClient();
client.connection.bind('connected', () => {
let channelName = 'a8hsuNFXUhfS1zoyvtDtiWE02Ra'; // 26 characters
client.subscribe(channelName);
client.connection.bind('message', ({ event, channel, data }) => {
if (event === 'pusher:subscription_error' && channel === channelName) {
expect(data.type).toBe('LimitReached');
expect(data.status).toBe(4009);
expect(data.error).toBeDefined();
done();
}
});
});
});
});
test('should check for presence.maxMemberSizeInKb', done => {
Utils.newServer({ 'presence.maxMemberSizeInKb': 1/1024/1024 }, (server: Server) => {
let user = {
user_id: 1,
user_info: {
id: 1,
name: 'John',
},
};
let client = Utils.newClientForPresenceUser(user);
let channelName = `presence-${Utils.randomChannelName()}`;
client.connection.bind('connected', () => {
client.subscribe(channelName);
client.connection.bind('message', ({ event, channel, data }) => {
if (event === 'pusher:subscription_error' && channel === channelName) {
expect(data.type).toBe('LimitReached');
expect(data.status).toBe(4301);
expect(data.error).toBeDefined();
done();
}
});
});
});
});
test('should check for presence.maxMembersPerChannel', done => {
Utils.newServer({ 'presence.maxMembersPerChannel': 1 }, (server: Server) => {
let user1 = {
user_id: 1,
user_info: {
id: 1,
name: 'John',
},
};
let user2 = {
user_id: 2,
user_info: {
id: 2,
name: 'Alice',
},
};
let client1 = Utils.newClientForPresenceUser(user1);
let channelName = `presence-${Utils.randomChannelName()}`;
client1.connection.bind('connected', () => {
let channel1 = client1.subscribe(channelName);
channel1.bind('pusher:subscription_succeeded', () => {
let client2 = Utils.newClientForPresenceUser(user2);
client2.connection.bind('message', ({ event, channel, data }) => {
if (event === 'pusher:subscription_error' && channel === channelName) {
expect(data.type).toBe('LimitReached');
expect(data.status).toBe(4100);
expect(data.error).toBeDefined();
done();
}
});
client2.subscribe(channelName);
});
});
});
});
test('adapter getSockets works', done => {
Utils.newServer({}, (server: Server) => {
let client1 = Utils.newClient();
client1.connection.bind('connected', () => {
server.adapter.getSockets('app-id').then(sockets => {
expect(sockets.size).toBe(1);
let client2 = Utils.newClient({});
client2.connection.bind('connected', () => {
server.adapter.getSockets('app-id').then(sockets => {
expect(sockets.size).toBe(2);
done();
});
});
})
});
});
});
test('adapter getChannelSockets works', done => {
Utils.newServer({}, (server: Server) => {
let client1 = Utils.newClient();
let channelName = Utils.randomChannelName();
client1.connection.bind('connected', () => {
server.adapter.getChannelSockets('app-id', channelName).then(sockets => {
expect(sockets.size).toBe(0);
let channel1 = client1.subscribe(channelName);
channel1.bind('pusher:subscription_succeeded', () => {
server.adapter.getChannelSockets('app-id', channelName).then(sockets => {
expect(sockets.size).toBe(1);
let client2 = Utils.newClient({});
client2.connection.bind('connected', () => {
let channel2 = client2.subscribe(channelName);
channel2.bind('pusher:subscription_succeeded', () => {
server.adapter.getChannelSockets('app-id', channelName).then(sockets => {
expect(sockets.size).toBe(2);
client2.unsubscribe(channelName);
Utils.wait(3000).then(() => {
server.adapter.getChannelSockets('app-id', channelName).then(sockets => {
expect(sockets.size).toBe(1);
done();
});
});
});
});
});
});
});
});
});
});
});
});
|
atymic/soketi
|
src/adapters/cluster-adapter.ts
|
import { HorizontalAdapter, PubsubBroadcastedMessage } from './horizontal-adapter';
import { Server } from '../server';
export class ClusterAdapter extends HorizontalAdapter {
/**
* The channel to broadcast the information.
*/
protected channel = 'cluster-adapter';
/**
* Initialize the adapter.
*/
constructor(server: Server) {
super(server);
this.channel = server.clusterPrefix(this.channel);
this.requestChannel = `${this.channel}#comms#req`;
this.responseChannel = `${this.channel}#comms#res`;
server.discover.join(this.requestChannel, this.onRequest.bind(this));
server.discover.join(this.responseChannel, this.onResponse.bind(this));
server.discover.join(this.channel, this.onMessage.bind(this));
}
/**
* Listen for requests coming from other nodes.
*/
protected onRequest(msg: any): void {
if (typeof msg === 'object') {
msg = JSON.stringify(msg);
}
super.onRequest(this.requestChannel, msg);
}
/**
* Handle a response from another node.
*/
protected onResponse(msg: any): void {
if (typeof msg === 'object') {
msg = JSON.stringify(msg);
}
super.onResponse(this.responseChannel, msg);
}
/**
* Listen for message coming from other nodes to broadcast
* a specific message to the local sockets.
*/
protected onMessage(msg: any): void {
if (typeof msg === 'string') {
msg = JSON.parse(msg);
}
let message: PubsubBroadcastedMessage = msg;
const { uuid, appId, channel, data, exceptingId } = message;
if (uuid === this.uuid || !appId || !channel || !data) {
return;
}
super.sendLocally(appId, channel, data, exceptingId);
}
/**
* Broadcast data to a given channel.
*/
protected broadcastToChannel(channel: string, data: any): void {
this.server.discover.send(channel, data);
}
/**
* Get the number of Discover nodes.
*/
protected getNumSub(): Promise<number> {
return Promise.resolve(this.server.nodes.size);
}
}
|
atymic/soketi
|
src/app-managers/index.ts
|
export * from './app-manager';
export * from './app-manager-interface';
export * from './array-app-manager';
export * from './base-app-manager';
export * from './dynamodb-app-manager';
export * from './mysql-app-manager';
export * from './postgres-app-manager';
export * from './sql-app-manager';
|
atymic/soketi
|
src/metrics/index.ts
|
export * from './metrics';
export * from './metrics-interface';
export * from './prometheus-metrics-driver';
|
atymic/soketi
|
src/channels/encrypted-private-channel-manager.ts
|
<filename>src/channels/encrypted-private-channel-manager.ts<gh_stars>100-1000
import { PrivateChannelManager } from './private-channel-manager';
export class EncryptedPrivateChannelManager extends PrivateChannelManager {
//
}
|
atymic/soketi
|
src/rate-limiters/index.ts
|
<reponame>atymic/soketi<filename>src/rate-limiters/index.ts
export * from './cluster-rate-limiter';
export * from './local-rate-limiter';
export * from './rate-limiter-interface';
export * from './rate-limiter';
export * from './redis-rate-limiter';
|
atymic/soketi
|
src/message.ts
|
<gh_stars>100-1000
export interface MessageData {
channel_data?: string;
channel?: string;
[key: string]: any;
}
export interface PusherMessage {
channel?: string;
name?: string;
event?: string;
data?: MessageData;
}
export interface PusherApiMessage {
name?: string;
data?: string|{ [key: string]: any };
channel?: string;
channels?: string[];
socket_id?: string;
}
export interface SentPusherMessage {
channel?: string;
event?: string;
data?: MessageData|string;
}
export type uWebSocketMessage = ArrayBuffer|PusherMessage;
|
atymic/soketi
|
src/http-handler.ts
|
<gh_stars>100-1000
import async from 'async';
import { HttpResponse, RecognizedString } from 'uWebSockets.js';
import { PusherApiMessage } from './message';
import { Server } from './server';
import { Utils } from './utils';
import { Log } from './log';
const v8 = require('v8');
export interface ChannelResponse {
subscription_count: number;
user_count?: number;
occupied: boolean;
}
export interface MessageCheckError {
message: string;
code: number;
}
export class HttpHandler {
/**
* Initialize the HTTP handler.
*/
constructor(protected server: Server) {
//
}
ready(res: HttpResponse) {
this.attachMiddleware(res, [
this.corsMiddleware,
]).then(res => {
if (this.server.closing) {
this.serverErrorResponse(res, 'The server is closing. Choose another server. :)');
} else {
this.send(res, 'OK');
}
});
}
healthCheck(res: HttpResponse) {
this.attachMiddleware(res, [
this.corsMiddleware,
]).then(res => {
this.send(res, 'OK');
});
}
usage(res: HttpResponse) {
this.attachMiddleware(res, [
this.corsMiddleware,
]).then(res => {
let {
rss,
heapTotal,
external,
arrayBuffers,
} = process.memoryUsage();
let totalSize = v8.getHeapStatistics().total_available_size;
let usedSize = rss + heapTotal + external + arrayBuffers;
let freeSize = totalSize - usedSize;
let percentUsage = (usedSize / totalSize) * 100;
return this.sendJson(res, {
memory: {
free: freeSize,
used: usedSize,
total: totalSize,
percent: percentUsage,
},
});
});
}
metrics(res: HttpResponse) {
this.attachMiddleware(res, [
this.corsMiddleware,
]).then(res => {
let handleError = err => {
this.serverErrorResponse(res, 'A server error has occurred.');
}
if (res.query.json) {
this.server.metricsManager
.getMetricsAsJson()
.then(metrics => {
this.sendJson(res, metrics);
})
.catch(handleError);
} else {
this.server.metricsManager
.getMetricsAsPlaintext()
.then(metrics => {
this.send(res, metrics);
})
.catch(handleError);
}
});
}
channels(res: HttpResponse) {
this.attachMiddleware(res, [
this.corsMiddleware,
this.appMiddleware,
this.authMiddleware,
this.readRateLimitingMiddleware,
]).then(res => {
this.server.adapter.getChannels(res.params.appId).then(channels => {
let response: { [channel: string]: ChannelResponse } = [...channels].reduce((channels, [channel, connections]) => {
if (connections.size === 0) {
return channels;
}
channels[channel] = {
subscription_count: connections.size,
occupied: true,
};
return channels;
}, {});
return response;
}).catch(err => {
Log.error(err);
return this.serverErrorResponse(res, 'A server error has occurred.');
}).then(channels => {
let broadcastMessage = { channels };
this.server.metricsManager.markApiMessage(res.params.appId, {}, broadcastMessage);
this.sendJson(res, broadcastMessage);
});
});
}
channel(res: HttpResponse) {
this.attachMiddleware(res, [
this.corsMiddleware,
this.appMiddleware,
this.authMiddleware,
this.readRateLimitingMiddleware,
]).then(res => {
let response: ChannelResponse;
this.server.adapter.getChannelSocketsCount(res.params.appId, res.params.channel).then(socketsCount => {
response = {
subscription_count: socketsCount,
occupied: socketsCount > 0,
};
// For presence channels, attach an user_count.
// Avoid extra call to get channel members if there are no sockets.
if (res.params.channel.startsWith('presence-')) {
response.user_count = 0;
if (response.subscription_count > 0) {
this.server.adapter.getChannelMembersCount(res.params.appId, res.params.channel).then(membersCount => {
let broadcastMessage = {
...response,
...{
user_count: membersCount,
},
};
this.server.metricsManager.markApiMessage(res.params.appId, {}, broadcastMessage);
this.sendJson(res, broadcastMessage);
}).catch(err => {
Log.error(err);
return this.serverErrorResponse(res, 'A server error has occurred.');
});
return;
}
}
this.server.metricsManager.markApiMessage(res.params.appId, {}, response);
return this.sendJson(res, response);
}).catch(err => {
Log.error(err);
return this.serverErrorResponse(res, 'A server error has occurred.');
});
});
}
channelUsers(res: HttpResponse) {
this.attachMiddleware(res, [
this.corsMiddleware,
this.appMiddleware,
this.authMiddleware,
this.readRateLimitingMiddleware,
]).then(res => {
if (!res.params.channel.startsWith('presence-')) {
return this.badResponse(res, 'The channel must be a presence channel.');
}
this.server.adapter.getChannelMembers(res.params.appId, res.params.channel).then(members => {
let broadcastMessage = {
users: [...members].map(([user_id, ]) => ({ id: user_id })),
};
this.server.metricsManager.markApiMessage(res.params.appId, {}, broadcastMessage);
this.sendJson(res, broadcastMessage);
});
});
}
events(res: HttpResponse) {
this.attachMiddleware(res, [
this.jsonBodyMiddleware,
this.corsMiddleware,
this.appMiddleware,
this.authMiddleware,
this.broadcastEventRateLimitingMiddleware,
]).then(res => {
this.checkMessageToBroadcast(res.body as PusherApiMessage).then(message => {
this.broadcastMessage(message, res.app.id);
this.sendJson(res, { ok: true });
}).catch(error => {
if (error.code === 400) {
this.badResponse(res, error.message);
} else if (error.code === 413) {
this.entityTooLargeResponse(res, error.message);
}
});
});
}
batchEvents(res: HttpResponse) {
this.attachMiddleware(res, [
this.jsonBodyMiddleware,
this.corsMiddleware,
this.appMiddleware,
this.authMiddleware,
this.broadcastBatchEventsRateLimitingMiddleware,
]).then(res => {
let batch = res.body.batch as PusherApiMessage[];
// Make sure the batch size is not too big.
if (batch.length > this.server.options.eventLimits.maxBatchSize) {
return this.badResponse(res, `Cannot batch-send more than ${this.server.options.eventLimits.maxBatchSize} messages at once`);
}
Promise.all(batch.map(message => this.checkMessageToBroadcast(message))).then(messages => {
messages.forEach(message => this.broadcastMessage(message, res.app.id));
this.sendJson(res, { ok: true });
}).catch((error: MessageCheckError) => {
if (error.code === 400) {
this.badResponse(res, error.message);
} else if (error.code === 413) {
this.entityTooLargeResponse(res, error.message);
}
});
});
}
protected checkMessageToBroadcast(message: PusherApiMessage): Promise<PusherApiMessage> {
return new Promise((resolve, reject) => {
if (
(!message.channels && !message.channel) ||
!message.name ||
!message.data
) {
return reject({
message: 'The received data is incorrect',
code: 400,
});
}
let channels: string[] = message.channels || [message.channel];
message.channels = channels;
// Make sure the channels length is not too big.
if (channels.length > this.server.options.eventLimits.maxChannelsAtOnce) {
return reject({
message: `Cannot broadcast to more than ${this.server.options.eventLimits.maxChannelsAtOnce} channels at once`,
code: 400,
});
}
// Make sure the event name length is not too big.
if (message.name.length > this.server.options.eventLimits.maxNameLength) {
return reject({
message: `Event name is too long. Maximum allowed size is ${this.server.options.eventLimits.maxNameLength}.`,
code: 400,
});
}
let payloadSizeInKb = Utils.dataToKilobytes(message.data);
// Make sure the total payload of the message body is not too big.
if (payloadSizeInKb > parseFloat(this.server.options.eventLimits.maxPayloadInKb as string)) {
return reject({
message: `The event data should be less than ${this.server.options.eventLimits.maxPayloadInKb} KB.`,
code: 413,
});
}
resolve(message);
});
}
protected broadcastMessage(message: PusherApiMessage, appId: string): void {
message.channels.forEach(channel => {
this.server.adapter.send(appId, channel, JSON.stringify({
event: message.name,
channel,
data: message.data,
}), message.socket_id);
});
this.server.metricsManager.markApiMessage(appId, message, { ok: true });
}
notFound(res: HttpResponse) {
//Send status before any headers.
res.writeStatus('404 Not Found');
this.attachMiddleware(res, [
this.corsMiddleware,
]).then(res => {
this.send(res, '', '404 Not Found');
});
}
protected badResponse(res: HttpResponse, error: string) {
return this.sendJson(res, { error, code: 400 }, '400 Invalid Request');
}
protected notFoundResponse(res: HttpResponse, error: string) {
return this.sendJson(res, { error, code: 404 }, '404 Not Found');
}
protected unauthorizedResponse(res: HttpResponse, error: string) {
return this.sendJson(res, { error, code: 401 }, '401 Unauthorized');
}
protected entityTooLargeResponse(res: HttpResponse, error: string) {
return this.sendJson(res, { error, code: 413 }, '413 Payload Too Large');
}
protected tooManyRequestsResponse(res: HttpResponse) {
return this.sendJson(res, { error: 'Too many requests.', code: 429 }, '429 Too Many Requests');
}
protected serverErrorResponse(res: HttpResponse, error: string) {
return this.sendJson(res, { error, code: 500 }, '500 Internal Server Error');
}
protected jsonBodyMiddleware(res: HttpResponse, next: CallableFunction): any {
this.readJson(res, (body, rawBody) => {
res.body = body;
res.rawBody = rawBody;
let requestSizeInMb = Utils.dataToMegabytes(rawBody);
if (requestSizeInMb > this.server.options.httpApi.requestLimitInMb) {
return this.entityTooLargeResponse(res, 'The payload size is too big.');
}
next(null, res);
}, err => {
return this.badResponse(res, 'The received data is incorrect.');
});
}
protected corsMiddleware(res: HttpResponse, next: CallableFunction): any {
res.writeHeader('Access-Control-Allow-Origin', this.server.options.cors.origin.join(', '));
res.writeHeader('Access-Control-Allow-Methods', this.server.options.cors.methods.join(', '));
res.writeHeader('Access-Control-Allow-Headers', this.server.options.cors.allowedHeaders.join(', '));
next(null, res);
}
protected appMiddleware(res: HttpResponse, next: CallableFunction): any {
return this.server.appManager.findById(res.params.appId).then(validApp => {
if (!validApp) {
return this.notFoundResponse(res, `The app ${res.params.appId} could not be found.`);
}
res.app = validApp;
next(null, res);
});
}
protected authMiddleware(res: HttpResponse, next: CallableFunction): any {
this.signatureIsValid(res).then(valid => {
if (valid) {
return next(null, res);
}
return this.unauthorizedResponse(res, 'The secret authentication failed');
});
}
protected readRateLimitingMiddleware(res: HttpResponse, next: CallableFunction): any {
this.server.rateLimiter.consumeReadRequestsPoints(1, res.app).then(response => {
if (response.canContinue) {
for (let header in response.headers) {
res.writeHeader(header, '' + response.headers[header]);
}
return next(null, res);
}
this.tooManyRequestsResponse(res);
});
}
protected broadcastEventRateLimitingMiddleware(res: HttpResponse, next: CallableFunction): any {
let channels = res.body.channels || [res.body.channel];
this.server.rateLimiter.consumeBackendEventPoints(Math.max(channels.length, 1), res.app).then(response => {
if (response.canContinue) {
for (let header in response.headers) {
res.writeHeader(header, '' + response.headers[header]);
}
return next(null, res);
}
this.tooManyRequestsResponse(res);
});
}
protected broadcastBatchEventsRateLimitingMiddleware(res: HttpResponse, next: CallableFunction): any {
let rateLimiterPoints = res.body.batch.reduce((rateLimiterPoints, event) => {
let channels: string[] = event.channels || [event.channel];
return rateLimiterPoints += channels.length;
}, 0);
this.server.rateLimiter.consumeBackendEventPoints(rateLimiterPoints, res.app).then(response => {
if (response.canContinue) {
for (let header in response.headers) {
res.writeHeader(header, '' + response.headers[header]);
}
return next(null, res);
}
this.tooManyRequestsResponse(res);
});
}
protected attachMiddleware(res: HttpResponse, functions: any[]): Promise<HttpResponse> {
return new Promise((resolve, reject) => {
let waterfallInit = callback => callback(null, res);
let abortHandlerMiddleware = (res, callback) => {
res.onAborted(() => {
Log.warning({ message: 'Aborted request.', res });
this.serverErrorResponse(res, 'Aborted request.');
});
callback(null, res);
};
async.waterfall([
waterfallInit.bind(this),
abortHandlerMiddleware.bind(this),
...functions.map(fn => fn.bind(this)),
], (err, res) => {
if (err) {
this.serverErrorResponse(res, 'A server error has occurred.');
Log.error(err);
return reject({ res, err });
}
resolve(res);
});
});
}
/**
* Read the JSON content of a request.
*/
protected readJson(res: HttpResponse, cb: CallableFunction, err: any) {
let buffer;
let loggingAction = (payload) => {
if (this.server.options.debug) {
Log.httpTitle('⚡ HTTP Payload received');
Log.http(payload);
}
};
res.onData((ab, isLast) => {
let chunk = Buffer.from(ab);
if (isLast) {
let json = {};
let raw = '{}';
if (buffer) {
try {
// @ts-ignore
json = JSON.parse(Buffer.concat([buffer, chunk]));
} catch (e) {
//
}
try {
raw = Buffer.concat([buffer, chunk]).toString();
} catch (e) {
//
}
cb(json, raw);
loggingAction(json);
} else {
try {
// @ts-ignore
json = JSON.parse(chunk);
raw = chunk.toString();
} catch (e) {
//
}
cb(json, raw);
loggingAction(json);
}
} else {
if (buffer) {
buffer = Buffer.concat([buffer, chunk]);
} else {
buffer = Buffer.concat([chunk]);
}
}
});
res.onAborted(err);
}
/**
* Check is an incoming request can access the api.
*/
protected signatureIsValid(res: HttpResponse): Promise<boolean> {
return this.getSignedToken(res).then(token => {
return token === res.query.auth_signature;
});
}
protected sendJson(res: HttpResponse, data: any, status: RecognizedString = '200 OK') {
return res.writeStatus(status)
.writeHeader('Content-Type', 'application/json')
// TODO: Remove after uWS19.4
// @ts-ignore Remove after uWS 19.4 release
.end(JSON.stringify(data), true);
}
protected send(res: HttpResponse, data: RecognizedString, status: RecognizedString = '200 OK') {
return res.writeStatus(status)
// TODO: Remove after uWS19.4
// @ts-ignore Remove after uWS 19.4 release
.end(data, true);
}
/**
* Get the signed token from the given request.
*/
protected getSignedToken(res: HttpResponse): Promise<string> {
return Promise.resolve(res.app.signingTokenFromRequest(res));
}
}
|
atymic/soketi
|
src/node.ts
|
<filename>src/node.ts<gh_stars>100-1000
export interface Node {
isMaster: boolean;
address: string;
port: number;
lastSeen: number;
id: string;
}
|
atymic/soketi
|
src/adapters/adapter-interface.ts
|
import { Namespace } from '../namespace';
import { PresenceMemberInfo } from '../channels/presence-channel-manager';
import { WebSocket } from 'uWebSockets.js';
const Discover = require('node-discover');
export interface AdapterInterface {
/**
* The app connections storage class to manage connections.
*/
namespaces?: Map<string, Namespace>;
/**
* The list of nodes in the current private network.
*/
driver?: AdapterInterface;
/**
* Get the app namespace.
*/
getNamespace(appId: string): Namespace;
/**
* Get all namespaces.
*/
getNamespaces(): Map<string, Namespace>;
/**
* Send a message to a namespace and channel.
*/
send(appId: string, channel: string, data: string, exceptingId?: string|null): any;
/**
* Clear the local namespaces.
*/
clear(namespaceId?: string, closeConnections?: boolean): Promise<void>;
/**
* Get all sockets from the namespace.
*/
getSockets(appId: string, onlyLocal?: boolean): Promise<Map<string, WebSocket>>;
/**
* Get total sockets count.
*/
getSocketsCount(appId: string, onlyLocal?: boolean): Promise<number>;
/**
* Get the list of channels with the websocket IDs.
*/
getChannels(appId: string, onlyLocal?: boolean): Promise<Map<string, Set<string>>>;
/**
* Get all the channel sockets associated with a namespace.
*/
getChannelSockets(appId: string, channel: string, onlyLocal?: boolean): Promise<Map<string, WebSocket>>;
/**
* Get a given channel's total sockets count.
*/
getChannelSocketsCount(appId: string, channel: string, onlyLocal?: boolean): Promise<number>;
/**
* Get a given presence channel's members.
*/
getChannelMembers(appId: string, channel: string, onlyLocal?: boolean): Promise<Map<string, PresenceMemberInfo>>;
/**
* Get a given presence channel's members count
*/
getChannelMembersCount(appId: string, channel: string, onlyLocal?: boolean): Promise<number>;
/**
* Check if a given connection ID exists in a channel.
*/
isInChannel(appId: string, channel: string, wsId: string, onlyLocal?: boolean): Promise<boolean>;
}
|
atymic/soketi
|
tests/public.test.ts
|
import { Server } from './../src/server';
import { Utils } from './utils';
describe('public channel test', () => {
beforeEach(() => {
jest.resetModules();
return Utils.waitForPortsToFreeUp();
});
afterEach(() => {
return Utils.flushServers();
});
test('connects to public channel', done => {
Utils.newServer({}, (server: Server) => {
let client = Utils.newClient();
let backend = Utils.newBackend();
let channelName = Utils.randomChannelName();
client.connection.bind('connected', () => {
let channel = client.subscribe(channelName);
channel.bind('greeting', e => {
expect(e.message).toBe('hello');
expect(e.weirdVariable).toBe('abc/d');
client.disconnect();
done();
});
channel.bind('pusher:subscription_succeeded', () => {
Utils.sendEventToChannel(backend, channelName, 'greeting', { message: 'hello', weirdVariable: 'abc/d' })
.catch(error => {
throw new Error(error);
});
});
});
});
});
test('connects and disconnected to public channel does not leak memory', done => {
Utils.newServer({}, (server: Server) => {
let client = Utils.newClient();
let backend = Utils.newBackend();
let channelName = Utils.randomChannelName();
client.connection.bind('disconnected', () => {
Utils.wait(3000).then(() => {
let namespace = server.adapter.getNamespace('app-id');
expect(namespace.sockets.size).toBe(0);
expect(namespace.channels.size).toBe(0);
done();
});
});
client.connection.bind('connected', () => {
let channel = client.subscribe(channelName);
channel.bind('greeting', e => {
expect(e.message).toBe('hello');
client.unsubscribe(channelName);
Utils.wait(3000).then(() => {
let namespace = server.adapter.getNamespace('app-id');
let socket = namespace.sockets.get(namespace.sockets.keys().next().value);
expect(namespace.channels.size).toBe(0);
expect(namespace.sockets.size).toBe(1);
expect(socket.subscribedChannels.size).toBe(0);
expect(socket.presence.size).toBe(0);
client.disconnect();
});
});
channel.bind('pusher:subscription_succeeded', () => {
Utils.sendEventToChannel(backend, channelName, 'greeting', { message: 'hello' });
});
});
});
});
test('sudden close connection in public channel does not leak memory', done => {
Utils.newServer({}, (server: Server) => {
let client = Utils.newClient();
let backend = Utils.newBackend();
let channelName = Utils.randomChannelName();
client.connection.bind('disconnected', () => {
Utils.wait(3000).then(() => {
let namespace = server.adapter.getNamespace('app-id');
expect(namespace.sockets.size).toBe(0);
expect(namespace.channels.size).toBe(0);
done();
});
});
client.connection.bind('connected', () => {
let channel = client.subscribe(channelName);
channel.bind('greeting', e => {
expect(e.message).toBe('hello');
client.disconnect();
});
channel.bind('pusher:subscription_succeeded', () => {
Utils.sendEventToChannel(backend, channelName, 'greeting', { message: 'hello' });
});
});
});
});
});
|
atymic/soketi
|
src/app.ts
|
<reponame>atymic/soketi
import { HttpResponse } from 'uWebSockets.js';
import { Lambda } from 'aws-sdk';
const Pusher = require('pusher');
const pusherUtil = require('pusher/lib/util');
export interface AppInterface {
id: string;
key: string;
secret: string;
maxConnections: string|number;
enableClientMessages: boolean;
enabled: boolean;
maxBackendEventsPerSecond?: string|number;
maxClientEventsPerSecond: string|number;
maxReadRequestsPerSecond?: string|number;
webhooks?: WebhookInterface[];
}
export interface WebhookInterface {
url?: string;
headers?: {
[key: string]: string;
};
lambda_function?: string;
event_types: string[];
filter?: {
channel_name_starts_with?: string;
channel_name_ends_with?: string;
};
lambda: {
async?: boolean;
region?: string;
client_options?: Lambda.Types.ClientConfiguration,
};
}
export class App implements AppInterface {
/**
* @type {string|number}
*/
public id: string;
/**
* @type {string|number}
*/
public key: string;
/**
* @type {string}
*/
public secret: string;
/**
* @type {number}
*/
public maxConnections: string|number;
/**
* @type {boolean}
*/
public enableClientMessages: boolean;
/**
* @type {boolean}
*/
public enabled: boolean;
/**
* @type {number}
*/
public maxBackendEventsPerSecond: string|number;
/**
* @type {number}
*/
public maxClientEventsPerSecond: string|number;
/**
* @type {number}
*/
public maxReadRequestsPerSecond: string|number;
/**
* @type {WebhookInterface[]}
*/
public webhooks: WebhookInterface[];
static readonly CLIENT_EVENT_WEBHOOK = 'client_event';
static readonly CHANNEL_OCCUPIED_WEBHOOK = 'channel_occupied';
static readonly CHANNEL_VACATED_WEBHOOK = 'channel_vacated';
static readonly MEMBER_ADDED_WEBHOOK = 'member_added';
static readonly MEMBER_REMOVED_WEBHOOK = 'member_removed';
/**
* Create a new app from object.
*/
constructor(app: { [key: string]: any; }) {
this.id = this.extractFromPassedKeys(app, ['id', 'AppId'], 'app-id');
this.key = this.extractFromPassedKeys(app, ['key', 'AppKey'], 'app-key');
this.secret = this.extractFromPassedKeys(app, ['secret', 'AppSecret'], 'app-secret');
this.maxConnections = this.extractFromPassedKeys(app, ['maxConnections', 'MaxConnections', 'max_connections'], -1);
this.enableClientMessages = this.extractFromPassedKeys(app, ['enableClientMessages', 'EnableClientMessages', 'enable_client_messages'], false);
this.enabled = this.extractFromPassedKeys(app, ['enabled', 'Enabled'], true);
this.maxBackendEventsPerSecond = parseInt(this.extractFromPassedKeys(app, ['maxBackendEventsPerSecond', 'MaxBackendEventsPerSecond', 'max_backend_events_per_sec'], -1));
this.maxClientEventsPerSecond = parseInt(this.extractFromPassedKeys(app, ['maxClientEventsPerSecond', 'MaxClientEventsPerSecond', 'max_client_events_per_sec'], -1));
this.maxReadRequestsPerSecond = parseInt(this.extractFromPassedKeys(app, ['maxReadRequestsPerSecond', 'MaxReadRequestsPerSecond', 'max_read_req_per_sec'], -1));
this.webhooks = this.transformPotentialJsonToArray(this.extractFromPassedKeys(app, ['webhooks', 'Webhooks'], '[]'));
}
/**
* Strip data off the app, usually the one that's not needed from the WS's perspective.
* Usually used when attached to WS connections, as they don't need these details.
*/
forWebSocket(): App {
// delete this.secret;
delete this.maxBackendEventsPerSecond;
delete this.maxReadRequestsPerSecond;
delete this.webhooks;
return this;
}
/**
* Get the signing token from the request.
*/
signingTokenFromRequest(res: HttpResponse): string {
const params = {
auth_key: this.key,
auth_timestamp: res.query.auth_timestamp,
auth_version: res.query.auth_version,
...res.query,
};
delete params['auth_signature'];
delete params['body_md5']
delete params['appId'];
delete params['appKey'];
delete params['channelName'];
if (res.rawBody) {
params['body_md5'] = pusherUtil.getMD5(res.rawBody);
}
return this.signingToken(
res.method,
res.url,
pusherUtil.toOrderedArray(params).join('&'),
);
}
/**
* Get the signing token for the given parameters.
*/
protected signingToken(method: string, path: string, params: string): string {
let token = new Pusher.Token(this.key, this.secret);
return token.sign([method, path, params].join("\n"));
}
/**
* Due to cross-database schema, it's worth to search multiple fields in the app in order to assign it
* to the local App object. For example, the local `enableClientMessages` attribute can exist as
* enableClientMessages, enable_client_messages, or EnableClientMessages. With this function, we pass
* the app, the list of all field posibilities, and a default value.
* This check is done with a typeof check over undefined, to make sure that false booleans or 0 values
* are being parsed properly and are not being ignored.
*/
protected extractFromPassedKeys(app: { [key: string]: any; }, parameters: string[], defaultValue: any): any {
let extractedValue = defaultValue;
parameters.forEach(param => {
if (typeof app[param] !== 'undefined') {
extractedValue = app[param];
}
});
return extractedValue;
}
/**
* If it's already an array, it returns the array. For an invalid JSON, it returns an empty array.
* If it's a JSON-formatted string, it parses it and returns the value.
*/
protected transformPotentialJsonToArray(potentialJson: any): any {
if (potentialJson instanceof Array) {
return potentialJson;
}
try {
let potentialArray = JSON.parse(potentialJson);
if (potentialArray instanceof Array) {
return potentialArray;
}
} catch (e) {
//
}
return [];
}
}
|
jaden-young/NWR
|
src/vscripts/lib/popups.d.ts
|
export {};
declare global {
enum PopupPreSymbol {
Plus = 0,
Minus = 1,
SadFace = 2,
BrokenArrow = 3,
Shades = 4,
Miss = 5,
Evade = 6,
Deny = 7,
Arrow = 8,
}
enum PopupPostSymbol {
Exclamation = 0,
PointZero = 1,
Medal = 2,
Drop = 3,
Lightning = 4,
Skull = 5,
Eye = 6,
Shield = 7,
PointFive = 8,
}
function PopupNumbers(target: CBaseEntity, pfx: string, color: Vector, lifetime: number, presymbol: PopupPreSymbol, postsymbol: PopupPostSymbol): void;
function PopupHealing(target: CBaseEntity, amount: number): void;
function PopupDamage(target: CBaseEntity, amount: number): void;
function PopupCriticalDamage(target: CBaseEntity, amount: number): void;
function PopupDamageOverTime(target: CBaseEntity, amount: number): void;
function PopupDamageBlock(target: CBaseEntity, amount: number): void;
function PopupGoldGain(target: CBaseEntity, amount: number): void;
function PopupMiss(target: CBaseEntity, amount: number): void;
function PopupExperience(target: CBaseEntity, amount: number): void;
function PopupMana(target: CBaseEntity, amount: number): void;
function PopupManaDrain(target: CBaseEntity, amount: number): void;
function PopupHealthTome(target: CBaseEntity, amount: number): void;
function PopupStrTome(target: CBaseEntity, amount: number): void;
function PopupAgiTome(target: CBaseEntity, amount: number): void;
function PopupIntTome(target: CBaseEntity, amount: number): void;
function PopupBleedingOverTime(target: CBaseEntity, amount: number): void;
function PopupMaterials(target: CBaseEntity, amount: number): void;
}
|
jaden-young/NWR
|
src/vscripts/lib/rescale.d.ts
|
declare interface Rescale {
RescaleUnit(unit: CDOTA_BaseNPC): void,
RescaleBuildings(): void,
RescaleShops(): void,
}
declare var Rescale: Rescale;
|
jaden-young/NWR
|
src/vscripts/components/voicelines/voicelines.d.ts
|
/**
* Relies on modifiers/modifier_responses.lua
*/
declare interface VoiceResponses {
Start(): void
RegisterUnit(unitName: string, configFile: string): void;
}
declare var VoiceResponses: VoiceResponses;
|
jaden-young/NWR
|
game/resource/localization/localizationTemplate.ts
|
import { AbilityLocalization, LocalizationData, ModifierLocalization, StandardLocalization } from "~generator/localizationInterfaces";
import { Language } from "../../languages";
// DigitalG:
// This is template for new localization file
// if you want to add new localization file (e.g. new hero) please copy this file
// DON't EDIT THIS
// For any questions please visit https://moddota.com/scripting/Typescript/tooltip-generator
export function GenerateLocalizationData(): LocalizationData
{
// This section can be safely ignored, as it is only logic.
//#region Localization logic
// Arrays
const Abilities: Array<AbilityLocalization> = new Array<AbilityLocalization>();
const Modifiers: Array<ModifierLocalization> = new Array<ModifierLocalization>();
const StandardTooltips: Array<StandardLocalization> = new Array<StandardLocalization>();
// Create object of arrays
const localization_info: LocalizationData =
{
AbilityArray: Abilities,
ModifierArray: Modifiers,
StandardArray: StandardTooltips,
};
//#endregion
// Enter localization data below!
// Return data to compiler
return localization_info;
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/zabuza/zabuza_innate_passive.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class zabuza_innate_passive extends BaseAbility
{
OnUpgrade(): void {
//Should refresh modifier on eanch upgrade
let caster = this.GetCaster()
caster.FindModifierByName(this.GetIntrinsicModifierName())?.ForceRefresh()
}
GetIntrinsicModifierName(): string {
return "modifier_zabuza_innate_passive_instrinsic"
}
}
@registerModifier()
export class modifier_zabuza_innate_passive_instrinsic extends BaseModifier
{
bonus_damage_per_stack: number = 0
bonus_attack_range_per_stack: number = 0
IsPurgable(): boolean {
return false
}
IsPermanent(): boolean {
return true
}
IsDebuff(): boolean {
return false
}
IsHidden(): boolean {
return false
}
UpdateNumbers(){
let ability = this.GetAbility()
if(!ability){return}
this.bonus_damage_per_stack = ability.GetSpecialValueFor("bonus_damage_per_stack")
this.bonus_attack_range_per_stack = ability.GetSpecialValueFor("bonus_attack_range_per_stack")
}
OnCreated(params: object): void {
this.UpdateNumbers()
}
OnRefresh(params: object): void {
this.UpdateNumbers()
}
DeclareFunctions(){
return [ModifierFunction.ON_DEATH,
ModifierFunction.PREATTACK_BONUS_DAMAGE,
ModifierFunction.ATTACK_RANGE_BONUS]
}
OnDeath(event: ModifierInstanceEvent){
let ability = this.GetAbility()
let parent = this.GetParent()
if(!ability){return}
if(event.attacker !== parent){return}
if(parent.PassivesDisabled()){return}
if(event.unit.GetTeam() === parent.GetTeam()){return}
let max_stacks = ability.GetSpecialValueFor("max_stacks_base") + (ability.GetSpecialValueFor("max_stacks_per_level_bonus") * (ability.GetLevel() - 1))
if(this.GetStackCount() < max_stacks){
this.IncrementStackCount()
}
}
GetModifierPreAttack_BonusDamage(){
return this.bonus_damage_per_stack * this.GetStackCount()
}
GetModifierAttackRangeBonus(){
return this.bonus_attack_range_per_stack * this.GetStackCount()
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/hidan/hidan_soul_hunt.ts
|
<reponame>jaden-young/NWR<filename>src/vscripts/abilities/heroes/hidan/hidan_soul_hunt.ts
import { BaseAbility, BaseModifier, BaseModifierMotionHorizontal, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface kv {
x: number;
y: number;
z: number;
}
@registerAbility()
export class hidan_soul_hunt extends BaseAbility
{
lightning_blade_fx?: ParticleID;
active_target?: CDOTA_BaseNPC;
/****************************************/
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/hidan/hidan_soul_hunt.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/hidan/game_sounds_hidan.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/hidan/game_sounds_vo_hidan.vsndevts", context);
}
/****************************************/
GetAOERadius(): number {
return this.GetSpecialValueFor("radius");
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster() as CDOTA_BaseNPC_Hero;
let origin = caster.GetAbsOrigin();
let duration = this.GetSpecialValueFor("slow_duration");
let base_damage = this.GetSpecialValueFor("base_damage");
let strength_dmg_mult = this.GetSpecialValueFor("strength_dmg_mult") / 100;
let strength = caster.GetStrength();
let damage_table: ApplyDamageOptions = {
attacker: caster,
victim: caster,
damage: base_damage + strength * strength_dmg_mult,
damage_type: this.GetAbilityDamageType(),
damage_flags: DamageFlag.NON_LETHAL + DamageFlag.BYPASSES_BLOCK,
ability: this
}
ApplyDamage(damage_table)
damage_table.damage_flags = DamageFlag.NONE;
let enemies = FindUnitsInRadius(
caster.GetTeamNumber(),
origin,
undefined,
this.GetAOERadius(),
UnitTargetTeam.ENEMY,
UnitTargetType.BASIC + UnitTargetType.HERO,
UnitTargetFlags.NONE,
FindOrder.ANY,
false
);
enemies.forEach(enemy => {
damage_table.victim = enemy;
ApplyDamage(damage_table);
enemy.AddNewModifier(caster, this, "modifier_hidan_soul_hunt", {duration: duration * (1 - enemy.GetStatusResistance())});
});
EmitSoundOn("Hero_Hidan.SoulHunt.Cast", caster);
ParticleManager.ReleaseParticleIndex(
ParticleManager.CreateParticle("particles/units/heroes/hidan/hidan_soul_hunt.vpcf", ParticleAttachment.ABSORIGIN, caster)
);
}
}
@registerModifier()
export class modifier_hidan_soul_hunt extends BaseModifierMotionHorizontal
{
movespeed_slow?: number;
/****************************************/
OnCreated(params: kv): void {
this.movespeed_slow = -this.GetAbility()!.GetSpecialValueFor("movespeed_slow");
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.MOVESPEED_BONUS_PERCENTAGE
]}
/****************************************/
GetModifierMoveSpeedBonus_Percentage(): number {
return this.movespeed_slow!;
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/onoki/onoki_atomic_dismantling.ts
|
<filename>src/vscripts/abilities/heroes/onoki/onoki_atomic_dismantling.ts
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class onoki_atomic_dismantling extends BaseAbility {
rock_fx?: ParticleID;
/****************************************/
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/onoki/onoki_atomic_dismantling.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/onoki/game_sounds_onoki.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/onoki/game_sounds_vo_onoki.vsndevts", context);
}
/****************************************/
GetAOERadius(): number {
return this.GetSpecialValueFor("radius");
}
/****************************************/
OnAbilityPhaseStart(): boolean {
let caster = this.GetCaster();
let position = this.GetCursorPosition();
let direction = position - caster.GetAbsOrigin() as Vector;
direction.z = 0;
direction = direction.Normalized();
this.rock_fx = ParticleManager.CreateParticle("particles/units/heroes/onoki/onoki_atomic_dismantling.vpcf", ParticleAttachment.ABSORIGIN, caster);
ParticleManager.SetParticleControl(this.rock_fx, 0, caster.GetAttachmentOrigin(caster.ScriptLookupAttachment("attach_hitloc")) + direction * 100 as Vector);
EmitSoundOn("Hero_Onoki.AtomicDismantling.Precast", caster);
EmitSoundOn("Hero_Onoki.AtomicDismantling.Talking", caster);
return true;
}
/****************************************/
OnAbilityPhaseInterrupted(): void {
ParticleManager.DestroyParticle(this.rock_fx!, true);
ParticleManager.ReleaseParticleIndex(this.rock_fx!);
StopSoundOn("Hero_Onoki.AtomicDismantling.Precast", this.GetCaster());
StopSoundOn("Hero_Onoki.AtomicDismantling.Talking", this.GetCaster());
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let position = this.GetCursorPosition();
let origin = caster.GetAbsOrigin();
let speed = this.GetSpecialValueFor("speed")
let direction = position - caster.GetAbsOrigin() as Vector;
direction.z = 0;
direction = direction.Normalized();
ProjectileManager.CreateLinearProjectile({
Ability: this,
EffectName: "",
vSpawnOrigin: caster.GetAttachmentOrigin(caster.ScriptLookupAttachment("attach_hitloc")) + direction * 75 as Vector,
fDistance: (position - origin as Vector).Length2D(),
Source: caster,
iUnitTargetTeam: UnitTargetTeam.NONE,
vVelocity: direction * speed as Vector,
});
EmitSoundOn("Hero_Onoki.AtomicDismantling.Cast", caster);
StopSoundOn("Hero_Onoki.AtomicDismantling.Precast", caster);
ParticleManager.SetParticleControl(this.rock_fx!, 1, GetGroundPosition(position, undefined) + Vector(0, 0, 75) as Vector);
ParticleManager.SetParticleControl(this.rock_fx!, 2, Vector(speed, 0, 0));
}
/****************************************/
OnProjectileHit(target: CDOTA_BaseNPC | undefined, location: Vector): boolean | void {
if (target || !this || this.IsNull()) return;
let caster = this.GetCaster()
let radius = this.GetSpecialValueFor("radius");
let root_duration = this.GetSpecialValueFor("root_duration");
let enemies = FindUnitsInRadius(
caster.GetTeamNumber(),
location,
undefined,
radius,
UnitTargetTeam.ENEMY,
UnitTargetType.BASIC + UnitTargetType.HERO,
UnitTargetFlags.NONE,
FindOrder.ANY,
false
);
enemies.forEach(enemy => {
enemy.AddNewModifier(caster, this, "modifier_onoki_atomic_dismantling", {duration: root_duration * (1 - enemy.GetStatusResistance())});
});
Timers.CreateTimer(root_duration, () => {
this.ApplySecondEffect(location);
});
EmitSoundOnLocationWithCaster(location, "Hero_Onoki.AtomicDismantling.Impact", caster);
ParticleManager.DestroyParticle(this.rock_fx!, false);
ParticleManager.ReleaseParticleIndex(this.rock_fx!);
let impact_fx = ParticleManager.CreateParticle("particles/units/heroes/onoki/onoki_atomic_dismantling_impact.vpcf", ParticleAttachment.ABSORIGIN, caster);
ParticleManager.SetParticleControl(impact_fx, 0, location);
ParticleManager.SetParticleControl(impact_fx, 1, location + Vector(0, 0, 150) as Vector);
Timers.CreateTimer(root_duration, () => {
ParticleManager.DestroyParticle(impact_fx, false)
ParticleManager.ReleaseParticleIndex(impact_fx)
})
}
/****************************************/
ApplySecondEffect(location: Vector) {
if (!this || this.IsNull()) return;
let caster = this.GetCaster()
let radius = this.GetSpecialValueFor("radius");
let stun_duration = this.GetSpecialValueFor("stun_duration");
let enemies = FindUnitsInRadius(
caster.GetTeamNumber(),
location,
undefined,
radius,
UnitTargetTeam.ENEMY,
UnitTargetType.BASIC + UnitTargetType.HERO,
UnitTargetFlags.NONE,
FindOrder.ANY,
false
);
enemies.forEach(enemy => {
enemy.AddNewModifier(caster, this, "modifier_stunned", {duration: stun_duration * (1 - enemy.GetStatusResistance())});
EmitSoundOn("Hero_Onoki.AtomicDismantling.Stun", enemy);
});
}
}
@registerModifier()
export class modifier_onoki_atomic_dismantling extends BaseModifier
{
IsPurgable(): boolean {return true}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {[ModifierState.ROOTED]: true};
}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/hero_treant/treant_bramble_root.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN;
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/kakashi/kakashi_innate_passive.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class kakashi_innate_passive extends BaseAbility
{
GetIntrinsicModifierName(): string {
return "modifier_kakashi_innate_passive"
}
/****************************************/
Spawn(): void {
if (IsServer()) {
this.SetLevel(1);
}
}
}
@registerModifier()
export class modifier_kakashi_innate_passive extends BaseModifier
{
parent: CDOTA_BaseNPC = this.GetParent();
damage_per_attr_point?: number;
stat_res_per_str?: number;
move_speed_per_agi?: number;
spell_amp_per_int?: number;
/****************************************/
IsHidden(): boolean {return true}
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return false}
/****************************************/
OnCreated(params: object): void {
let ability = this.GetAbility()!;
this.damage_per_attr_point = ability.GetSpecialValueFor("damage_per_attr_point");
this.stat_res_per_str = ability.GetSpecialValueFor("stat_res_per_str");
this.move_speed_per_agi = ability.GetSpecialValueFor("move_speed_per_agi");
this.spell_amp_per_int = ability.GetSpecialValueFor("move_speed_per_agi");
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.BASEATTACK_BONUSDAMAGE,
ModifierFunction.STATUS_RESISTANCE_STACKING,
ModifierFunction.MOVESPEED_BONUS_PERCENTAGE,
ModifierFunction.SPELL_AMPLIFY_PERCENTAGE
]}
/****************************************/
GetModifierBaseAttack_BonusDamage(): number {
return this.damage_per_attr_point! * this.GetTotalAttributes() - (this.parent as CDOTA_BaseNPC_Hero).GetAgility();
}
/****************************************/
GetModifierStatusResistanceStacking(): number {
if (this.GetParent().PassivesDisabled()) return 0;
return this.stat_res_per_str! * (this.parent as CDOTA_BaseNPC_Hero).GetStrength();
}
/****************************************/
GetModifierMoveSpeedBonus_Percentage(): number {
if (this.GetParent().PassivesDisabled()) return 0;
return this.move_speed_per_agi! * (this.parent as CDOTA_BaseNPC_Hero).GetStrength();
}
/****************************************/
GetModifierSpellAmplify_Percentage(): number {
if (this.GetParent().PassivesDisabled()) return 0;
return this.spell_amp_per_int! * (this.parent as CDOTA_BaseNPC_Hero).GetStrength();
}
/****************************************/
GetTotalAttributes(): number {
return (this.parent as CDOTA_BaseNPC_Hero).GetStrength() +
(this.parent as CDOTA_BaseNPC_Hero).GetAgility() +
(this.parent as CDOTA_BaseNPC_Hero).GetIntellect();
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/haku/haku_innate_passive.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class haku_innate_passive extends BaseAbility
{
OnUpgrade(): void {
//Should refresh modifier on eanch upgrade
this.GetCaster().FindModifierByName(this.GetIntrinsicModifierName())?.ForceRefresh()
}
GetIntrinsicModifierName(): string {
return "modifier_haku_innate_passive_intrinsic"
}
Precache(context: CScriptPrecacheContext){
PrecacheResource("particle", "particles/units/heroes/haku/haku_wounds_debuff.vpcf", context)
}
ApplyStacks(target: CDOTA_BaseNPC, stacks_count: number){
if(target.IsBuilding()){return}
if(this.GetCaster().PassivesDisabled()){return}
if(!target.HasModifier("modifier_haku_innate_passive_victim_counter"))
{
target.AddNewModifier(this.GetCaster(),
this,
"modifier_haku_innate_passive_victim_counter",
{duration: this.GetSpecialValueFor("duration")})
}
let counter_modifier = target.FindModifierByNameAndCaster("modifier_haku_innate_passive_victim_counter", this.GetCaster())
let current_stacks_count = counter_modifier?.GetStackCount() ?? 0
let new_stacks_count = current_stacks_count + stacks_count
let max_stacks_count = this.GetSpecialValueFor("max_stacks_base") + this.GetSpecialValueFor("max_stacks_per_level_bonus")*(this.GetLevel()-1)
let stacks_to_add = new_stacks_count > max_stacks_count ? math.max(max_stacks_count - current_stacks_count, 0) : stacks_count
if(stacks_to_add>0){
for(let i=0; i<stacks_to_add; i++){
print("adding_modifier")
target.AddNewModifier(this.GetCaster(),
this,
"modifier_haku_innate_passive_victim",
{duration: this.GetSpecialValueFor("duration")})
}
}
}
}
@registerModifier()
export class modifier_haku_innate_passive_intrinsic extends BaseModifier {
caster?: CDOTA_BaseNPC;
ability?: CDOTABaseAbility;
stacks? : number;
IsHidden(): boolean {
return false
}
IsPermanent(): boolean {
return true
}
IsPurgable(): boolean {
return true
}
DeclareFunctions() {
return [ModifierFunction.ON_ATTACK_LANDED]
}
OnCreated(params: object): void {
this.caster = this.GetCaster();
this.ability = this.GetAbility();
this.stacks = 0;
}
OnRefresh(params: object): void {
this.caster = this.GetCaster();
this.ability = this.GetAbility();
}
OnAttackLanded( event: ModifierAttackEvent){
if(event.attacker == this.caster){
let stacks_per_attack = this.ability?.GetSpecialValueFor("stacks_per_attack")
if(!event.target.IsMagicImmune()){
(this.ability as haku_innate_passive).ApplyStacks(event.target, stacks_per_attack ?? 0)
}
}
}
}
@registerModifier()
export class modifier_haku_innate_passive_victim_counter extends BaseModifier {
current_stacks: number = 0;
slow_per_stack: number = 0;
duration: number = 0;
dot_damage_table?: ApplyDamageOptions;
slow_vfx?: ParticleID;
IsHidden(): boolean {
return false
}
IsPurgable(): boolean {
return true
}
IsDebuff(): boolean {
return true
}
OnCreated(params: object): void {
this.current_stacks = 0
this.slow_per_stack = (this.GetAbility()?.GetSpecialValueFor("ms_slow_per_stack") ?? 0)
let talent_ability = this.GetCaster()?.FindAbilityByName("special_bonus_haku_1")
if(talent_ability && talent_ability.GetLevel() > 0){
this.slow_per_stack += talent_ability.GetSpecialValueFor("value")
}
this.duration = (this.GetAbility()?.GetSpecialValueFor("duration") ?? 0)
if(!IsServer()){return}
this.slow_vfx = ParticleManager.CreateParticle("particles/units/heroes/haku/haku_wounds_debuff.vpcf",
ParticleAttachment.ABSORIGIN_FOLLOW,
this.GetAbility()?.GetCaster())
ParticleManager.SetParticleControlEnt(this.slow_vfx, 0, this.GetParent(), ParticleAttachment.POINT_FOLLOW, "origin", this.GetParent().GetOrigin(), true )
let ability = this.GetAbility()
if(ability){
this.dot_damage_table = {
victim: this.GetParent(),
attacker: ability?.GetCaster(),
damage_type: ability?.GetAbilityDamageType(),
damage: 1,
damage_flags: 0,
ability: ability,
}
}
this.StartIntervalThink(1)
}
OnIntervalThink(): void {
let current_stacks = (this.GetStackCount() ?? 0)
if(this.dot_damage_table){
this.dot_damage_table.damage = current_stacks
ApplyDamage(this.dot_damage_table)
SendOverheadEventMessage(
undefined,
OverheadAlert.BONUS_SPELL_DAMAGE,
this.GetParent(),
current_stacks,
this.GetCaster()?.GetPlayerOwner()
)
}
}
OnRemoved(): void {
if(this.slow_vfx){
ParticleManager.DestroyParticle(this.slow_vfx, false)
ParticleManager.ReleaseParticleIndex(this.slow_vfx)
}
}
OnDestroy(): void {
}
ChangeStacks(change: number){
let current_stacks = this.GetStackCount()
this.SetStackCount(current_stacks + change)
this.current_stacks = current_stacks + change
if(this.slow_vfx){
ParticleManager.SetParticleControl(this.slow_vfx, 1, Vector(this.current_stacks, 0, 0))
}
if(current_stacks + change >= 0 && change > 0){
this.SetDuration(this.duration, true)
}
}
DeclareFunctions() {
return [ModifierFunction.MOVESPEED_BONUS_PERCENTAGE]
}
GetModifierMoveSpeedBonus_Percentage(){
return this.slow_per_stack * this.GetStackCount()
}
}
@registerModifier()
export class modifier_haku_innate_passive_victim extends BaseModifier{
IsHidden(): boolean {
return true
}
IsPurgable(): boolean {
return true
}
IsDebuff(): boolean {
return true
}
GetAttributes(): ModifierAttribute {
return ModifierAttribute.MULTIPLE
}
OnCreated(params: object): void {
let target = this.GetParent()
let caster = this.GetCaster()
if(IsServer() && caster && target) {
let counter = target.FindModifierByNameAndCaster("modifier_haku_innate_passive_victim_counter", caster)
if(counter){
(counter as modifier_haku_innate_passive_victim_counter).ChangeStacks(1)
}
}
}
OnRemoved(): void {
let target = this.GetParent()
let caster = this.GetCaster()
if(IsServer() && caster && target) {
let counter = target.FindModifierByNameAndCaster("modifier_haku_innate_passive_victim_counter", caster)
if(counter){
(counter as modifier_haku_innate_passive_victim_counter).ChangeStacks(-1)
}
}
}
OnDestroy(): void {
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/raikage/raikage_liger_bomb.ts
|
import { BaseAbility, BaseModifier, BaseModifierMotionHorizontal, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface kv {
target: EntityIndex;
}
interface LigerBombAbility extends CDOTABaseAbility{
CastLigerBomb(target: CDOTA_BaseNPC, shard: boolean): void;
}
@registerAbility()
export class raikage_liger_bomb extends BaseAbility {
Precache(context: CScriptPrecacheContext): void {
PrecacheResource("particle", "particles/units/heroes/raikage/raikage_liger_bomb_impact.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/raikage/game_sounds_raikage.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/raikage/game_sounds_vo_raikage.vsndevts", context);
}
/****************************************/
GetCastRange(location: Vector, target: CDOTA_BaseNPC | undefined): number {
return this.GetCaster().HasShard() ? this.GetSpecialValueFor("shard_range") : super.GetCastRange(location, target);
}
/****************************************/
GetAOERadius(): number {
return this.GetSpecialValueFor("radius");
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let target = this.GetCursorTarget() as CDOTA_BaseNPC;
let distance = (caster.GetAbsOrigin() - target.GetAbsOrigin() as Vector).Length2D();
if (caster.HasShard() && distance > this.GetSpecialValueFor("shard_cast_distance")) {
caster.AddNewModifier(caster, this, "modifier_raikage_liger_bomb_charge", {duration: -1, target: target?.entindex()})
} else {
this.CastLigerBomb(target, false);
}
}
/****************************************/
CastLigerBomb(target: CDOTA_BaseNPC, shard: boolean): void {
let caster = this.GetCaster();
shard ? caster.StartGesture(GameActivity.DOTA_CAST_ABILITY_7) : caster.StartGesture(GameActivity.DOTA_CAST_ABILITY_6);
let origin = target.GetAbsOrigin();
let knockback_duration = this.GetSpecialValueFor("knockback_duration");
if (target.TriggerSpellAbsorb(this)) return;
let kv = {
center_x: origin.x,
center_y: origin.y,
center_z: origin.z,
should_stun: true,
duration: knockback_duration,
knockback_duration: knockback_duration,
knockback_distance: 0,
knockback_height: this.GetSpecialValueFor("knockback_height_tgt"),
}
target.AddNewModifier(caster, this, "modifier_knockback", kv);
origin = caster.GetAbsOrigin();
kv.center_x = origin.x;
kv.center_y = origin.y;
kv.center_z = origin.z;
kv.should_stun = false;
kv.knockback_height = this.GetSpecialValueFor("knockback_height_caster");
caster.AddNewModifier(caster, this, "modifier_knockback", kv);
caster.AddNewModifier(caster, this, "modifier_raikage_liger_bomb_caster", {duration: knockback_duration});
Timers.CreateTimer(knockback_duration, () => this.FinishCast(target, shard));
shard ? EmitSoundOn("VO_Hero_Raikage.Drop.Cast", caster) : EmitSoundOn("VO_Hero_Raikage.LigerBomb.Cast", caster);
EmitSoundOn("Hero_Raikage.LigerBomb.Cast", caster);
}
/****************************************/
FinishCast(target: CDOTA_BaseNPC, shard: boolean): void {
let caster = this.GetCaster();
let duration = this.GetSpecialValueFor("stun_duration");
let shard_duration = this.GetSpecialValueFor("shard_duration");
let damage = this.GetSpecialValueFor("damage");
let has_shard = caster.HasShard();
let enemies = FindUnitsInRadius(
caster.GetTeamNumber(),
target.GetAbsOrigin(),
undefined,
this.GetSpecialValueFor("radius"),
UnitTargetTeam.ENEMY,
UnitTargetType.BASIC + UnitTargetType.HERO,
UnitTargetFlags.NONE,
FindOrder.ANY,
false
);
let damage_table = {
attacker: caster,
victim: caster,
damage: this.GetSpecialValueFor("damage"),
damage_type: this.GetAbilityDamageType(),
ability: this
}
enemies.forEach(enemy => {
if (has_shard) {
enemy.AddNewModifier(caster, this, "modifier_raikage_liger_bomb", {duration: shard_duration * (1 - target.GetStatusResistance())});
}
damage_table.damage = enemy == target ? damage : damage * 0.5;
damage_table.victim = enemy;
ApplyDamage(damage_table);
enemy.AddNewModifier(caster, this, "modifier_stunned", {duration: duration * (1 - target.GetStatusResistance())});
});
EmitSoundOn("Hero_Raikage.LigerBomb.Impact", caster);
shard ? caster.FadeGesture(GameActivity.DOTA_CAST_ABILITY_7) : caster.FadeGesture(GameActivity.DOTA_CAST_ABILITY_6);
ParticleManager.ReleaseParticleIndex(
ParticleManager.CreateParticle("particles/units/heroes/raikage/raikage_liger_bomb_impact.vpcf", ParticleAttachment.ABSORIGIN, target)
)
}
}
@registerModifier()
export class modifier_raikage_liger_bomb_charge extends BaseModifierMotionHorizontal
{
target?: CDOTA_BaseNPC;
charge_speed?: number;
shard_cast_distance?: number;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
IsHidden(): boolean {return true}
/****************************************/
OnCreated(params: kv): void {
let ability = this.GetAbility()!;
this.charge_speed = ability.GetSpecialValueFor("shard_speed");
this.shard_cast_distance = ability.GetSpecialValueFor("shard_cast_distance");
if (!IsServer()) return;
this.target = EntIndexToHScript(params.target) as CDOTA_BaseNPC;
if (!this.ApplyHorizontalMotionController()) {
this.Destroy()
return;
}
}
OnDestroy(): void {
if (!IsServer()) return;
this.GetParent().RemoveHorizontalMotionController(this);
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.OVERRIDE_ANIMATION,
]}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.NO_UNIT_COLLISION]: true,
[ModifierState.FLYING_FOR_PATHING_PURPOSES_ONLY]: true,
[ModifierState.INVULNERABLE]: true
};
}
/****************************************/
UpdateHorizontalMotion(parent: CDOTA_BaseNPC, dt: number): void {
let direction = (this.target!.GetAbsOrigin() - parent.GetAbsOrigin() as Vector).Normalized();
this.CheckConditions();
if (this.CheckDistance()) return;
parent.FaceTowards(this.target!.GetAbsOrigin());
parent.SetAbsOrigin(parent.GetAbsOrigin() + this.charge_speed! * direction * dt as Vector);
}
/****************************************/
OnHorizontalMotionInterrupted(): void {
this.Destroy();
}
/****************************************/
GetOverrideAnimation(): GameActivity{
return GameActivity.DOTA_CHANNEL_ABILITY_6
}
/****************************************/
CheckConditions(): void {
let parent = this.GetParent();
if (parent.IsStunned() || parent.IsHexed() || parent.IsRooted() || this.target?.IsNull() || !this.target?.IsAlive()) this.Destroy();
}
/****************************************/
CheckDistance(): boolean {
let parent = this.GetParent();
let distance = (parent.GetAbsOrigin() - this.target!.GetAbsOrigin() as Vector).Length2D()
if (distance <= this.shard_cast_distance!) {
let parent = this.GetParent();
let ability = this.GetAbility() as LigerBombAbility;
parent.RemoveHorizontalMotionController(this);
if (this.target && !this.target.IsNull() && this.target.IsAlive()) {
ability.CastLigerBomb(this.target, true);
}
this.Destroy()
return true;
} else if (distance > 3000) {
this.Destroy();
return true;
}
return false;
}
}
@registerModifier()
export class modifier_raikage_liger_bomb extends BaseModifier
{
armor_reduction?: number;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: Object): void {
let parent = this.GetParent();
let ability = this.GetAbility()!;
this.armor_reduction = -ability.GetSpecialValueFor("shard_armor_reduction");
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.PHYSICAL_ARMOR_BONUS
]}
/****************************************/
GetModifierPhysicalArmorBonus(): number {
return this.armor_reduction!;
}
}
@registerModifier()
export class modifier_raikage_liger_bomb_caster extends BaseModifier
{
IsPurgable(): boolean {return false}
IsHidden(): boolean {return true}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.COMMAND_RESTRICTED]: true
};
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/shisui/shisui_halo_dance.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class shisui_halo_dance extends BaseAbility {
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/shisui/shisui_halo_dance_wave.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/shisui/game_sounds_shisui.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/shisui/game_sounds_vo_shisui.vsndevts", context);
}
/****************************************/
GetCastRange(location: Vector, target: CDOTA_BaseNPC | undefined): number {
return this.GetSpecialValueFor("wave_range") + this.GetCaster().FindTalentValue("special_bonus_shisui_2");
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
caster.AddNewModifier(caster, this, "modifier_shisui_halo_dance", {duration: this.GetSpecialValueFor("duration")});
EmitSoundOn("Hero_Shisui.Halo.Cast", caster);
}
/****************************************/
OnProjectileHit(target: CDOTA_BaseNPC | undefined, location: Vector): boolean | void {
if (!target) return;
ApplyDamage({
attacker: this.GetCaster(),
victim: target,
damage: this.GetSpecialValueFor("damage") + this.GetCaster().FindTalentValue("special_bonus_shisui_1"),
damage_type: this.GetAbilityDamageType(),
ability: this
})
}
}
@registerModifier()
export class modifier_shisui_halo_dance extends BaseModifier
{
speed?: number;
shard_attack_range: number = 0;
shard_attack_speed: number = 0;
projectile?: CreateLinearProjectileOptions;
/****************************************/
OnCreated(params: object): void {
if (!IsServer()) return;
let ability = this.GetAbility();
let parent = this.GetParent();
let wave_radius = ability?.GetSpecialValueFor("wave_radius");
let wave_range = ability!.GetSpecialValueFor("wave_range") + parent.FindTalentValue("special_bonus_shisui_2");
this.speed = ability?.GetSpecialValueFor("wave_speed");
if (parent.HasShard()) {
this.shard_attack_range = ability!.GetSpecialValueFor("shard_range");
this.shard_attack_speed = ability!.GetSpecialValueFor("shard_attack_speed");
}
this.projectile = {
Ability: this.GetAbility(),
EffectName: "particles/units/heroes/shisui/shisui_halo_dance_wave.vpcf",
vSpawnOrigin: parent.GetAttachmentOrigin(parent.ScriptLookupAttachment("attach_attack1")) as Vector,
Source: parent,
bHasFrontalCone: true,
fDistance: wave_range,
fStartRadius: wave_radius,
fEndRadius: wave_radius,
iUnitTargetTeam: ability?.GetAbilityTargetTeam(),
iUnitTargetType: ability?.GetAbilityTargetType(),
iUnitTargetFlags: ability?.GetAbilityTargetFlags(),
vVelocity: undefined
}
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.ON_ATTACK_LANDED,
ModifierFunction.ATTACK_RANGE_BONUS,
ModifierFunction.ATTACKSPEED_BONUS_CONSTANT
]}
/****************************************/
OnAttackLanded(event: ModifierAttackEvent): void {
if (!IsServer()) return;
let attacker = event.attacker;
let target = event.target;
if (attacker != this.GetParent() || target.IsBuilding() || target.IsOther()) return;
this.projectile!.vSpawnOrigin = attacker.GetAttachmentOrigin(attacker.ScriptLookupAttachment("attach_attack1")) as Vector,
this.projectile!.vVelocity = (target.GetAbsOrigin() - attacker.GetAbsOrigin() as Vector).Normalized() * this.speed! as Vector;
ProjectileManager.CreateLinearProjectile(this.projectile!);
EmitSoundOn("Hero_Shisui.Halo.Fire", target);
}
/****************************************/
GetModifierAttackRangeBonus(): number {
return this.shard_attack_range;
}
/****************************************/
GetModifierAttackSpeedBonus_Constant(): number {
return this.shard_attack_speed;
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/sakura/sakura_innate_passive.ts
|
<filename>src/vscripts/abilities/heroes/sakura/sakura_innate_passive.ts
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class sakura_innate_passive extends BaseAbility
{
OnUpgrade(): void {
//Should refresh modifier on eanch upgrade
let caster = this.GetCaster()
caster.FindModifierByName(this.GetIntrinsicModifierName())?.ForceRefresh()
}
GetIntrinsicModifierName(): string {
return "modifier_sakura_innate_passive_intrinsic"
}
}
@registerModifier()
export class modifier_sakura_innate_passive_intrinsic extends BaseModifier
{
active_fx?: ParticleID;
IsHidden(): boolean {
return false;
}
IsDebuff(): boolean {
return false;
}
IsPurgable(): boolean {
return false;
}
IsPermanent(): boolean {
return false
}
DeclareFunctions(){
return [ModifierFunction.ON_ATTACK_LANDED]
}
OnAttackLanded(event: ModifierAttackEvent){
if(event.attacker !== this.GetParent()){return}
if(event.target.IsBuilding()){return}
if(this.GetParent().PassivesDisabled()){return}
if(this.GetParent().GetTeam() === event.target.GetTeam()){return}
let ability = this.GetAbility()
if(!ability){return}
if (this.CanProc()){
this.ProcEnhancedStrength(event.target, true);
} else {
this.IncrementStackCount()
}
}
OnStackCountChanged(stackCount: number): void {
if (!IsServer()) return;
if (this.GetStackCount() == this.GetAbility()?.GetSpecialValueFor("attacks_needed") && this.active_fx == undefined) {
this.active_fx = ParticleManager.CreateParticle("particles/units/heroes/sakura/sakura_chakra_enhanced_strength.vpcf", ParticleAttachment.OVERHEAD_FOLLOW, this.GetParent());
}
}
CanProc(): boolean {
let attacks_needed = this.GetAbility()!.GetSpecialValueFor("attacks_needed");
return this.GetStackCount() === attacks_needed;
}
ProcEnhancedStrength(target: CDOTA_BaseNPC, reset: boolean): void {
let ability = this.GetAbility()!;
let stun_duration = ability.GetSpecialValueFor("stun_duration_base") + (ability.GetSpecialValueFor("stun_duration_per_level_bonus") * (ability.GetLevel() - 1))
target.AddNewModifier(this.GetParent(), ability, "modifier_sakura_innate_passive_stun", {duration: stun_duration})
if (reset) {
this.SetStackCount(0);
this.ClearParticle();
}
let damage = ability.GetSpecialValueFor("damage_base") + (ability.GetSpecialValueFor("damage_per_level_bonus") * (ability.GetLevel() - 1))
let damage_options = {
victim: target,
attacker: this.GetParent(),
damage: damage,
damage_type: DamageTypes.PHYSICAL,
damage_flags: DamageFlag.NONE
}
ApplyDamage(damage_options)
SendOverheadEventMessage(
undefined,
OverheadAlert.BONUS_SPELL_DAMAGE,
target,
damage,
this.GetCaster()?.GetPlayerOwner()
)
target.EmitSound("sakura_strength_impact")
}
ClearParticle(): void {
ParticleManager.DestroyParticle(this.active_fx!, false);
ParticleManager.ReleaseParticleIndex(this.active_fx!);
this.active_fx = undefined;
}
}
@registerModifier()
export class modifier_sakura_innate_passive_stun extends BaseModifier
{
IsDebuff(): boolean {
return true
}
IsStunDebuff(): boolean {
return true
}
GetEffectName(): string {
return "particles/generic_gameplay/generic_stunned.vpcf"
}
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.OVERHEAD_FOLLOW
}
DeclareFunctions(){
return [ModifierFunction.OVERRIDE_ANIMATION]
}
GetOverrideAnimation(){
return GameActivity.DOTA_DISABLED
}
CheckState(){
return {
[ModifierState.STUNNED]: true
}
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/kakashi/kakashi_lightning_release.ts
|
<reponame>jaden-young/NWR
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class kakashi_lightning_release extends BaseAbility {
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/kakashi/lightning_cloneactive.vpcf", context);
PrecacheResource("particle", "particles/units/heroes/kakashi/bunshin_zapped_root.vpcf", context);
PrecacheResource("particle", "particles/units/heroes/kakashi/bunshin_counter_active.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/kakashi/game_sounds_kakashi.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/kakashi/game_sounds_vo_kakashi.vsndevts", context);
}
/****************************************/
GetBehavior(): AbilityBehavior | Uint64 {
if (this.GetCaster().HasModifier("modifier_kakashi_kamui_channeling")) {
return AbilityBehavior.NO_TARGET + AbilityBehavior.IMMEDIATE + AbilityBehavior.IGNORE_CHANNEL;
} else {
return super.GetBehavior();
}
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let duration = this.GetSpecialValueFor("active_duration");
caster.AddNewModifier(caster, this, "modifier_kakashi_lightning_release", {duration: duration});
}
}
@registerModifier()
export class modifier_kakashi_lightning_release extends BaseModifier
{
damage?: number;
root_duration?: number;
invis_duration?: number;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: Object): void {
let ability = this.GetAbility()!;
let parent = this.GetParent();
this.damage = ability.GetSpecialValueFor("damage");
this.root_duration = ability.GetSpecialValueFor("root_duration") + parent.FindTalentValue("special_bonus_kakashi_3");
this.invis_duration = ability.GetSpecialValueFor("invis_duration") + parent.FindTalentValue("special_bonus_kakashi_4");
EmitSoundOn("Hero_Kakashi.LightningRelease.Counter", parent);
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.ON_TAKEDAMAGE,
ModifierFunction.ABSOLUTE_NO_DAMAGE_MAGICAL,
ModifierFunction.ABSOLUTE_NO_DAMAGE_PHYSICAL,
ModifierFunction.ABSOLUTE_NO_DAMAGE_PURE
]}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/kakashi/bunshin_counter_active.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN;
}
OnTakeDamage(params: ModifierInstanceEvent): void {
if (!IsServer()) return;
let unit = params.unit;
let ability = this.GetAbility();
let attacker = params.attacker;
if (!unit || unit != this.GetParent() || !attacker.IsOwnedByAnyPlayer()) return;
if (bit.band(params.damage_flags, DamageTypes.HP_REMOVAL) == DamageTypes.HP_REMOVAL) return;
unit.Purge(false, true, false, false, false);
unit.AddNewModifier(unit, ability, "modifier_kakashi_lightning_release_invisibility", {duration: this.invis_duration});
EmitSoundOn("Hero_Kakashi.LightningRelease.Proc", unit);
let release_fx = ParticleManager.CreateParticle("particles/units/heroes/kakashi/lightning_cloneactive.vpcf", ParticleAttachment.WORLDORIGIN, undefined);
ParticleManager.SetParticleControl(release_fx, 0, unit.GetAbsOrigin());
ParticleManager.ReleaseParticleIndex(release_fx);
let damage_table: ApplyDamageOptions = {
attacker: unit,
victim: unit,
damage: this.damage!,
damage_type: ability?.GetAbilityDamageType()!,
ability: ability
}
let enemies = FindUnitsInRadius(unit.GetTeamNumber(), unit.GetAbsOrigin(), undefined, 300, UnitTargetTeam.ENEMY, UnitTargetType.HERO + UnitTargetType.BASIC, UnitTargetFlags.NO_INVIS, FindOrder.ANY, false);
enemies.forEach((enemy) => {
if (!enemy.IsMagicImmune()) {
damage_table.victim = enemy;
ApplyDamage(damage_table);
enemy.AddNewModifier(unit, ability, "modifier_kakashi_lightning_release_root", {duration: this.root_duration! * (1 - enemy.GetStatusResistance())});
EmitSoundOn("Hero_Kakashi.LightningRelease.Zap", enemy);
}
});
this.Destroy();
}
/****************************************/
GetAbsoluteNoDamagePure(event: ModifierAttackEvent): 0 | 1 {
return this.ShouldNegateDamage(event.attacker);
}
/****************************************/
GetAbsoluteNoDamageMagical(event: ModifierAttackEvent): 0 | 1 {
return this.ShouldNegateDamage(event.attacker);
}
/****************************************/
GetAbsoluteNoDamagePhysical(event: ModifierAttackEvent): 0 | 1 {
return this.ShouldNegateDamage(event.attacker);
}
/****************************************/
ShouldNegateDamage(attacker: CDOTA_BaseNPC): 0 | 1 {
if (!IsServer()) return 0;
if (attacker && attacker.IsOwnedByAnyPlayer()) return 1;
return 0;
}
}
@registerModifier()
export class modifier_kakashi_lightning_release_invisibility extends BaseModifier
{
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.INVISIBILITY_LEVEL,
ModifierFunction.ON_ATTACK_LANDED,
ModifierFunction.ON_ABILITY_EXECUTED
]}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.INVISIBLE]: true,
[ModifierState.NO_UNIT_COLLISION]: true
};
}
/****************************************/
GetModifierInvisibilityLevel(): number {
return 1
}
/****************************************/
OnAttackLanded(event: ModifierAttackEvent): void {
if (!IsServer()) return;
if (event.attacker != this.GetParent()) return;
this.Destroy();
}
/****************************************/
OnAbilityExecuted(event: ModifierAbilityEvent): void {
if (!IsServer()) return;
if (event.unit != this.GetParent()) return;
this.Destroy();
}
}
@registerModifier()
export class modifier_kakashi_lightning_release_root extends BaseModifier
{
IsPurgable(): boolean {return true}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {[ModifierState.ROOTED]: true};
}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/kakashi/bunshin_zapped_root.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN;
}
}
|
jaden-young/NWR
|
src/panorama/multiteam_flyout_scoreboard.ts
|
<reponame>jaden-young/NWR<gh_stars>0
//@ts-nocheck
"use strict";
var g_ScoreboardHandle = null;
function SetFlyoutScoreboardVisible( bVisible )
{
$.GetContextPanel().SetHasClass( "flyout_scoreboard_visible", bVisible );
if ( bVisible )
{
ScoreboardUpdater_SetScoreboardActive( g_ScoreboardHandle, true );
}
else
{
ScoreboardUpdater_SetScoreboardActive( g_ScoreboardHandle, false );
}
}
function OnKillEvent( event )
{
var containerPanel = $( "#TeamsContainer" );
var teamId = event.victim_team_id
var teamPanelName = "_dynamic_team_" + teamId;
var teamPanel = containerPanel.FindChild( teamPanelName );
var playersContainer = teamPanel.FindChildInLayoutFile( "PlayersContainer" );
var playerPanelName = "_dynamic_player_" + event.victim_id;
var playerPanel = playersContainer.FindChild( playerPanelName );
if (playerPanelName !== null){
var childPanel = playerPanel.FindChildInLayoutFile( "DeathsContainer" );
var panel = childPanel.FindChildInLayoutFile( "Deaths" );
panel.text = parseInt(panel.text) + 1;
}
var containerPanel = $( "#TeamsContainer" );
var teamId = event.team_id
var teamPanelName = "_dynamic_team_" + teamId;
var teamPanel = containerPanel.FindChild( teamPanelName );
var playersContainer = teamPanel.FindChildInLayoutFile( "PlayersContainer" );
var playerPanelName = "_dynamic_player_" + event.killer_id;
if (playerPanelName != null){
var playerPanel = playersContainer.FindChild( playerPanelName );
var childPanel = playerPanel.FindChildInLayoutFile( "KillsContainer" );
var panel = childPanel.FindChildInLayoutFile( "Kills" );
panel.text = parseInt(panel.text) + 1;
}
}
function OnLastHitEvent( event )
{
var containerPanel = $( "#TeamsContainer" );
var teamId = event.team_id
var teamPanelName = "_dynamic_team_" + teamId;
var teamPanel = containerPanel.FindChild( teamPanelName );
var teamPlayers = Game.GetPlayerIDsOnTeam( teamId );
var playersContainer = teamPanel.FindChildInLayoutFile( "PlayersContainer" );
var playerPanelName = "_dynamic_player_" + event.killer_id;
var playerPanel = playersContainer.FindChild( playerPanelName );
if (playerPanel != null){
var childPanel = playerPanel.FindChildInLayoutFile( "LastHitsContainer" );
var panel = childPanel.FindChildInLayoutFile( "LastHits" );
panel.text = parseInt(panel.text) + 1;
}
}
function OnDenyEvent( event )
{
var containerPanel = $( "#TeamsContainer" );
var teamId = event.team_id
var teamPanelName = "_dynamic_team_" + teamId;
var teamPanel = containerPanel.FindChild( teamPanelName );
var teamPlayers = Game.GetPlayerIDsOnTeam( teamId );
var playersContainer = teamPanel.FindChildInLayoutFile( "PlayersContainer" );
var playerPanelName = "_dynamic_player_" + event.killer_id;
var playerPanel = playersContainer.FindChild( playerPanelName );
if (playerPanel != null){
var childPanel = playerPanel.FindChildInLayoutFile( "DeniesContainer" );
var panel = childPanel.FindChildInLayoutFile( "Denies" );
panel.text = parseInt(panel.text) + 1;
}
}
function OnHeroInGame( event )
{
var scoreboardConfig =
{
"teamXmlName" : "file://{resources}/layout/custom_game/multiteam_flyout_scoreboard_team.xml",
"playerXmlName" : "file://{resources}/layout/custom_game/multiteam_flyout_scoreboard_player.xml",
};
g_ScoreboardHandle = ScoreboardUpdater_InitializeScoreboard( scoreboardConfig, $( "#TeamsContainer" ) );
var assistsData = event[2]
var teamData = event[1]
var count = event[3]
for (var i = 0; i < count; ++i)
{
var containerPanel = $( "#TeamsContainer" );
var teamId = teamData[i+1]
var teamPanelName = "_dynamic_team_" + teamId;
var teamPanel = containerPanel.FindChild( teamPanelName );
var teamPlayers = Game.GetPlayerIDsOnTeam( teamId );
var playersContainer = teamPanel.FindChildInLayoutFile( "PlayersContainer" );
var playerPanelName = "_dynamic_player_" + (i);
var playerPanel = playersContainer.FindChild( playerPanelName );
if (playerPanel != null) {
var childPanel = playerPanel.FindChildInLayoutFile( "AssistsContainer" );
var panel = childPanel.FindChildInLayoutFile( "Assists" );
panel.text = parseInt(assistsData[i+1]);
}
}
}
(function()
{
if ( ScoreboardUpdater_InitializeScoreboard === null ) { $.Msg( "WARNING: This file requires shared_scoreboard_updater.js to be included." ); }
var scoreboardConfig =
{
"teamXmlName" : "file://{resources}/layout/custom_game/multiteam_flyout_scoreboard_team.xml",
"playerXmlName" : "file://{resources}/layout/custom_game/multiteam_flyout_scoreboard_player.xml",
};
g_ScoreboardHandle = ScoreboardUpdater_InitializeScoreboard( scoreboardConfig, $( "#TeamsContainer" ) );
SetFlyoutScoreboardVisible( false );
$.RegisterEventHandler( "DOTACustomUI_SetFlyoutScoreboardVisible", $.GetContextPanel(), SetFlyoutScoreboardVisible );
GameEvents.Subscribe( "hero_killed", OnKillEvent );
GameEvents.Subscribe( "lasthit", OnLastHitEvent );
GameEvents.Subscribe( "deny", OnDenyEvent );
GameEvents.Subscribe( "initiate", OnHeroInGame );
})();
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/itachi/itachi_ephemeral.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class itachi_ephemeral extends BaseAbility
{
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/itachi/ephemeral.vpcf", context);
PrecacheResource("particle", "particles/units/heroes/hero_techies/techies_taunt_swing_around_hit_shockwave.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/itachi/game_sounds_itachi.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/itachi/game_sounds_vo_itachi.vsndevts", context);
}
/****************************************/
GetCooldown(level: number): number {
return super.GetCooldown(level) - this.GetCaster()!.FindTalentValue("special_bonus_itachi_2");
}
/****************************************/
GetCastRange(location: Vector, target: CDOTA_BaseNPC | undefined): number {
return IsClient() ? super.GetCastRange(location, target) : 50000;
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let origin = caster.GetAbsOrigin();
let position = this.GetCursorPosition();
let range = this.GetSpecialValueFor("cast_range");
let silence_duration = this.GetSpecialValueFor("silence_duration") + caster.FindTalentValue("special_bonus_itachi_3");
let distance = (position - origin as Vector).Length2D();
EmitSoundOnLocationWithCaster(origin, "Hero_Itachi.Ephemeral.Cast", caster);
EmitSoundOnLocationWithCaster(origin, "Hero_Itachi.BlinkLayer", caster);
let ephemeral_fx = ParticleManager.CreateParticle("particles/units/heroes/itachi/ephemeral.vpcf", ParticleAttachment.CUSTOMORIGIN, undefined);
ParticleManager.SetParticleControl(ephemeral_fx, 0, origin);
ParticleManager.ReleaseParticleIndex(ephemeral_fx);
position = distance < range ? position : (position - origin as Vector).Normalized() * range + origin as Vector;
FindClearSpaceForUnit(caster, position, true)
ProjectileManager.ProjectileDodge(caster);
if (caster.HasShard()) this.FearEnemies(caster, origin);
let enemies = FindUnitsInRadius(
caster.GetTeamNumber(),
position, undefined,
this.GetSpecialValueFor("radius"),
UnitTargetTeam.ENEMY,
UnitTargetType.BASIC + UnitTargetType.HERO,
UnitTargetFlags.NONE,
FindOrder.ANY,
false
);
enemies.forEach(enemy => {
enemy.AddNewModifier(caster, this, "modifier_itachi_ephemeral", {duration: silence_duration * (1 - enemy.GetStatusResistance())});
});
ParticleManager.ReleaseParticleIndex(
ParticleManager.CreateParticle("particles/units/heroes/hero_techies/techies_taunt_swing_around_hit_shockwave.vpcf", ParticleAttachment.ABSORIGIN, caster)
);
EmitSoundOn("Hero_Itachi.BlinkLayer", caster);
}
FearEnemies(caster: CDOTA_BaseNPC, position: Vector) {
print(this.GetSpecialValueFor("shard_fear_radius"))
let duration = this.GetSpecialValueFor("shard_fear_duration")
let enemies = FindUnitsInRadius(
caster.GetTeamNumber(),
position,
undefined,
this.GetSpecialValueFor("shard_fear_radius"),
UnitTargetTeam.ENEMY,
UnitTargetType.BASIC + UnitTargetType.HERO,
UnitTargetFlags.NONE,
FindOrder.ANY,
false
)
enemies.forEach(enemy => {
print("ayaya")
enemy.AddNewModifier(caster, this, "modifier_nevermore_necromastery_fear", {duration: duration * (1 - enemy.GetStatusResistance())});
});
}
}
@registerModifier()
export class modifier_itachi_ephemeral extends BaseModifier
{
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.SILENCED]: true,
};
}
/****************************************/
GetEffectName(): string {
return "particles/generic_gameplay/generic_silenced.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.OVERHEAD_FOLLOW;
}
/****************************************/
ShouldUseOverheadOffset(): boolean {
return true;
}
}
|
jaden-young/NWR
|
src/vscripts/extended_api.ts
|
export {}
declare global {
interface CDOTA_BaseNPC {
GetAllAbilities(): CDOTABaseAbility[];
GetTalentSpecialValueFor(talentName: string): number;
FindTalentValue(talentName: string, key?: string): number;
}
}
if (IsServer()) {
CDOTA_BaseNPC.GetAllAbilities = function() {
let abilities: CDOTABaseAbility[] = [];
for (let i=0; i<DOTA_MAX_ABILITIES; i++) {
let ability = this.GetAbilityByIndex(i);
if (ability) {
abilities.push(ability);
}
}
return abilities;
}
CDOTA_BaseNPC.GetTalentSpecialValueFor = function (talentName: string) {
let talent = this.FindAbilityByName(talentName);
return talent ? talent.GetSpecialValueFor("value") : 0;
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/sasuke/sasuke_sharingan.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class sasuke_sharingan extends BaseAbility {
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/sasuke/sasuke_sharingan_buff.vpcf", context);
PrecacheResource("particle", "particles/units/heroes/sasuke/sasuke_sharingan_evade.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/sasuke/game_sounds_sasuke.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/sasuke/game_sounds_vo_sasuke.vsndevts", context);
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
caster.AddNewModifier(caster, this, "modifier_sasuke_sharingan", {duration: this.GetSpecialValueFor("duration")});
EmitSoundOn("Hero_Sasuke.Sharingan.Cast", caster);
}
}
@registerModifier()
export class modifier_sasuke_sharingan extends BaseModifier
{
attack_speed?: number;
instances?: number;
min_damage?: number;
dodge_fx?: ParticleID
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: Object): void {
let ability = this.GetAbility()!;
this.attack_speed = ability.GetSpecialValueFor("bonus_attack_speed");
this.instances = ability.GetSpecialValueFor("instances");
this.min_damage = ability.GetSpecialValueFor("min_damage");
if (!IsServer()) return;
this.SetStackCount(this.instances);
this.dodge_fx = ParticleManager.CreateParticle("particles/units/heroes/sasuke/sasuke_sharingan_evade.vpcf", ParticleAttachment.ABSORIGIN_FOLLOW, this.GetParent());
ParticleManager.SetParticleControlEnt(this.dodge_fx, 3, this.GetParent(), ParticleAttachment.ABSORIGIN_FOLLOW, "attach_hitloc", Vector(0, 0, 0), true);
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.ATTACKSPEED_BONUS_CONSTANT,
ModifierFunction.INCOMING_DAMAGE_PERCENTAGE
]}
/****************************************/
GetModifierAttackSpeedBonus_Constant(): number {
return this.attack_speed!;
}
/****************************************/
GetModifierIncomingDamage_Percentage(event: ModifierAttackEvent): number {
let reduction = 0;
if (event.damage_type != DamageTypes.HP_REMOVAL && event.damage > this.min_damage! && this.GetStackCount() > 0) {
reduction = -100;
EmitSoundOn("Hero_Sasuke.Sharingan.Dodge", this.GetParent());
let warp_fx = ParticleManager.CreateParticle("particles/units/heroes/sasuke/sasuke_sharingan_dodge.vpcf", ParticleAttachment.ABSORIGIN_FOLLOW, this.GetParent());
ParticleManager.SetParticleControlEnt(warp_fx, 0, this.GetParent(), ParticleAttachment.POINT_FOLLOW, "attach_hitloc", Vector(0, 0, 0), true);
ParticleManager.ReleaseParticleIndex(warp_fx);
this.DecrementStackCount();
if (this.GetStackCount() == 0) {
ParticleManager.DestroyParticle(this.dodge_fx!, false);
ParticleManager.ReleaseParticleIndex(this.dodge_fx!);
}
}
return reduction;
}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/sasuke/sasuke_sharingan_buff.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN;
}
}
|
jaden-young/NWR
|
src/vscripts/lib/adv_log.d.ts
|
<reponame>jaden-young/NWR
/**
* Also overrides default `print()` function to log at level `info` and support
* printing tables
*/
declare interface log {
debug(obj: any): void;
info(obj: any): void;
warn(obj: any): void;
critical(obj: any): void;
crit(obj: any): void;
error(obj: any): void;
}
declare var log: log;
|
jaden-young/NWR
|
src/vscripts/lib/client_util.d.ts
|
<filename>src/vscripts/lib/client_util.d.ts
declare function CreateEmptyTalents(hero: string): void;
/**
* Client-side implementation of some base NPC extensions.
* Moddota types don't let me extend C_DOTA_BaseNPC.
*/
declare interface CDOTA_BaseNPC {
HasTalent(talentName: string): boolean;
FindTalentValue(talentName: string, key?: string): number;
GetTalentSpecialValueFor(value: string): number;
HasShard(): boolean;
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/sasuke/sasuke_innate_passive.ts
|
<filename>src/vscripts/abilities/heroes/sasuke/sasuke_innate_passive.ts
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class sasuke_innate_passive extends BaseAbility
{
OnUpgrade(): void {
//Should refresh modifier on eanch upgrade
let caster = this.GetCaster()
caster.FindModifierByName(this.GetIntrinsicModifierName())?.ForceRefresh()
}
GetIntrinsicModifierName(): string {
return "modifier_sasuke_innate_passive_intrinsic"
}
Precache(context: CScriptPrecacheContext){
PrecacheResource( "soundfile", "soundevents/heroes/sasuke/sasuke_sword_impact.vsndevts", context )
}
}
@registerModifier()
export class modifier_sasuke_innate_passive_intrinsic extends BaseModifier
{
duration?: number;
IsHidden(): boolean {
return true
}
IsDebuff(): boolean {
return false
}
IsPermanent(): boolean {
return true
}
IsPurgable(): boolean {
return false
}
OnCreated(params: object): void {
this.duration = this.GetAbility()?.GetSpecialValueFor("expire_after");
}
DeclareFunctions(){
return [ModifierFunction.ON_ABILITY_FULLY_CAST]
}
OnAbilityFullyCast(event: ModifierAbilityEvent){
let parent = this.GetParent()
let ability = this.GetAbility()
if(!ability){return}
if(event.unit !== parent){return}
if(parent.PassivesDisabled()){return}
parent.AddNewModifier(parent, ability, "modifier_sasuke_innate_passive_caster_buff", {duration: this.duration});
}
}
@registerModifier()
export class modifier_sasuke_innate_passive_caster_buff extends BaseModifier{
IsHidden(): boolean {
return false
}
IsDebuff(): boolean {
return false
}
IsPermanent(): boolean {
return false
}
IsPurgable(): boolean {
return true
}
DeclareFunctions(){ return [
ModifierFunction.ON_ATTACK_LANDED,
ModifierFunction.TRANSLATE_ACTIVITY_MODIFIERS
]}
OnCreated(params: object): void {
let parent = this.GetParent()
let particle_cast = "particles/units/heroes/hero_stormspirit/stormspirit_overload_ambient.vpcf"
let effect_cast = ParticleManager.CreateParticle( particle_cast, ParticleAttachment.ABSORIGIN_FOLLOW, parent )
ParticleManager.SetParticleControlEnt(
effect_cast,
0,
parent,
ParticleAttachment.POINT_FOLLOW,
"attach_attack1",
Vector(0,0,0),
true,
)
this.AddParticle(
effect_cast,
false, // bDestroyImmediately
false, // bStatusEffect
-1, // iPriority
false, // bHeroEffect
false // bOverheadEffect
)
}
GetActivityTranslationModifiers(): string {
return "chidori"
}
OnAttackLanded(event: ModifierAttackEvent){
let ability = this.GetAbility()
let parent = this.GetParent()
if(!ability){return}
if(event.attacker !== parent){return}
if(event.target.IsBuilding()){return}
if(event.target.GetTeam() === parent.GetTeam()){return}
let debuff_duration = ability.GetSpecialValueFor("debuff_duration")
let bonus_damage = ability.GetSpecialValueFor("bonus_damage_base") + (ability.GetSpecialValueFor("bonus_damage_per_level_bonus") * (ability.GetLevel() - 1))
let damage_table = {
victim: event.target,
attacker: parent,
damage: bonus_damage,
damage_type: ability.GetAbilityDamageType(),
damage_flags: DamageFlag.NONE,
ability: ability
}
ApplyDamage(damage_table)
event.target.AddNewModifier(parent, ability, "modifier_sasuke_innate_passive_debuff", {duration: debuff_duration})
let particle = ParticleManager.CreateParticle("particles/units/heroes/hero_stormspirit/stormspirit_overload_discharge.vpcf", ParticleAttachment.ABSORIGIN_FOLLOW, event.target)
ParticleManager.DestroyParticle(particle, false)
ParticleManager.ReleaseParticleIndex(particle)
event.target.EmitSound("sasuke_sword_impact")
this.Destroy()
}
}
@registerModifier()
export class modifier_sasuke_innate_passive_debuff extends BaseModifier
{
movement_speed_slow_percentange: number = 0;
attack_speed_slow: number = 0;
IsHidden(): boolean {
return false
}
IsDebuff(): boolean {
return true
}
IsPermanent(): boolean {
return false
}
IsPurgable(): boolean {
return true
}
OnCreated(params: object): void {
let ability = this.GetAbility()
if(!ability){return}
this.movement_speed_slow_percentange = ability.GetSpecialValueFor("movement_speed_slow_percentange")
this.attack_speed_slow = ability.GetSpecialValueFor("attack_speed_slow")
}
DeclareFunctions(){
return [ModifierFunction.MOVESPEED_BONUS_PERCENTAGE,
ModifierFunction.ATTACKSPEED_BONUS_CONSTANT]
}
GetModifierMoveSpeedBonus_Percentage(){
return this.movement_speed_slow_percentange * -1
}
GetModifierAttackSpeedBonus_Constant(){
return this.attack_speed_slow * -1
}
}
|
jaden-young/NWR
|
src/panorama/hud_hero_demo.ts
|
<gh_stars>0
//@ts-nocheck
function ToggleEnemyHeroPicker() {
$('#SelectAllyHeroContainer').SetHasClass('HeroPickerVisible', false)
$('#SelectEnemyHeroContainer').ToggleClass('HeroPickerVisible');
}
function ToggleAllyHeroPicker() {
$('#SelectEnemyHeroContainer').SetHasClass('HeroPickerVisible', false)
$('#SelectAllyHeroContainer').ToggleClass('HeroPickerVisible');
}
function SpawnEnemyNewHero(nHeroID) {
$('#SelectEnemyHeroContainer').RemoveClass('HeroPickerVisible');
$.DispatchEvent('FireCustomGameEvent_Str', 'SpawnEnemyButtonPressed', String(nHeroID));
}
function SpawnAllyNewHero(nHeroID) {
$('#SelectAllyHeroContainer').RemoveClass('HeroPickerVisible');
$.DispatchEvent('FireCustomGameEvent_Str', 'SpawnAllyButtonPressed', String(nHeroID));
}
// 点击槽ä½åˆ‡æ¢å¯é€‰ç‰©å“æ é—包
function SelectSlot(EconItemSlot, SlotStorePanel) {
return function () {
Game.EmitSound('ui.books.pageturns');
var StyleMenus = $.GetContextPanel().FindChildrenWithClassTraverse("EconItemStyleContents");
var unit = Players.GetLocalPlayerPortraitUnit();
var container = $("#UnitItemContainer" + unit.toString());
for (var child of StyleMenus) {
child.SetHasClass("Hidden", true);
}
if (EconItemSlot != null) {
var EconItemSlotParent = EconItemSlot.GetParent();
for (var child of EconItemSlotParent.Children()) {
child.SetHasClass("Selected", false);
}
EconItemSlot.SetHasClass("Selected", true);
if (container) {
container.FindChildTraverse("Bundle").SetHasClass("SourceButtonDisabled", true);
container.FindChildTraverse("Single").SetHasClass("SourceButtonDisabled", false);
}
} else {
// 点击é¢æ¿ï¼Œåˆ‡æ¢åˆ°æ†ç»‘包æ
var children = $.GetContextPanel().FindChildrenWithClassTraverse("Selected");
for (var child of children) {
if (child.BHasClass("EconItemSlot")) {
child.SetHasClass("Selected", false);
}
}
if (container) {
container.FindChildTraverse("Bundle").SetHasClass("SourceButtonDisabled", false);
container.FindChildTraverse("Single").SetHasClass("SourceButtonDisabled", true);
}
}
var SlotStoreParent = SlotStorePanel.GetParent();
for (var child of SlotStoreParent.Children()) {
child.SetHasClass("Hidden", true);
}
SlotStorePanel.SetHasClass("Hidden", false);
}
};
// 切æ¢é¥°å“é—包
function SwitchWearable(itemDef, itemStyle) {
if (!itemStyle) {
itemStyle = 0;
}
return function () {
$.Msg('SwitchWearable ', itemDef, ' ', itemStyle);
var unit = Players.GetLocalPlayerPortraitUnit();
GameEvents.SendCustomGameEventToServer("SwitchWearable", { "unit": unit, "itemDef": itemDef, "itemStyle": itemStyle });
}
};
/*
// 切æ¢ä¿¡ä½¿é—包
function SwitchCourier(itemDef, itemStyle, bFlying, bDire) {
return function () {
$.Msg('SwitchCourier ', itemDef, ' ', itemStyle, ' ', bFlying, ' ', bDire);
// å¿…é¡»é‡æ–°è®¾ä¸€ä¸ªæ–°å˜é‡ï¼Œå¦åˆ™é—包将维护å˜é‡
var _itemDef = itemDef;
var _itemStyle = itemStyle;
var _bFlying = bFlying;
var _bDire = bDire;
var unit = Players.GetLocalPlayerPortraitUnit();
var container = $("#UnitItemContainer" + unit.toString());
if (container) {
var CourierSelectorContainer = container.FindChildTraverse("CourierSelectorContainer");
if (CourierSelectorContainer.bFlying && _bFlying === undefined) {
_bFlying = CourierSelectorContainer.bFlying;
}
}
if (!_itemStyle) {
_itemStyle = 0;
}
if (!_bFlying) {
_bFlying = false;
}
if (!_bDire) {
_bDire = false;
}
SendEventToServerWithCallback(
"SwitchCourier",
{
"unit": unit,
"itemDef": _itemDef,
"itemStyle": _itemStyle,
"bFlying": _bFlying,
'bDire': _bDire,
},
function (params) {
Game.EmitSound('ui.courier_in_use');
var slotName = "courier";
if (container) {
var CourierSelectorContainer = container.FindChildTraverse("CourierSelectorContainer");
CourierSelectorContainer.itemDef = _itemDef;
CourierSelectorContainer.itemStyle = _itemStyle;
CourierSelectorContainer.bFlying = _bFlying;
CourierSelectorContainer.bDire = _bDire;
var TeamSelectorContainer = container.FindChildTraverse("TeamSelectorContainer");
if (_bDire) {
TeamSelectorContainer.SetHasClass("DireSelected", true);
} else {
TeamSelectorContainer.SetHasClass("DireSelected", false);
}
var FlySelectorContainer = container.FindChildTraverse("FlySelectorContainer");
if (_bFlying) {
FlySelectorContainer.SetHasClass("FlySelected", true);
} else {
FlySelectorContainer.SetHasClass("FlySelected", false);
}
var EquipContainer = container.FindChildTraverse("EquipItemContainer");
var EconItemSlot = EquipContainer.FindChildTraverse(slotName);
if (EconItemSlot) {
var EconItem = GetEconItem(EconItemSlot);
var StyleMenu = $("#" + EconItem.id + "StyleMenu");
EconItem.DeleteAsync(0);
if (StyleMenu) {
StyleMenu.DeleteAsync(0);
}
var uid = GetUniqueID();
var econItemText = '<DOTAEconItem id="' + uid + '" class="DisableInspect" itemdef="' + _itemDef + '" onload="SetEconItemButtons(\'' + uid + '\', \'' + _itemDef + '\', ' + _itemStyle + ')" />';
EconItemSlot.BCreateChildren(econItemText);
}
}
}
);
}
};
function SwitchCourierTeam(bDire) {
var unit = Players.GetLocalPlayerPortraitUnit();
var container = $("#UnitItemContainer" + unit.toString());
if (container) {
var CourierSelectorContainer = container.FindChildTraverse("CourierSelectorContainer");
var itemDef = CourierSelectorContainer.itemDef;
var itemStyle = CourierSelectorContainer.itemStyle;
var bFlying = CourierSelectorContainer.bFlying;
SwitchCourier(itemDef, itemStyle, bFlying, bDire)();
}
}
function SwitchCourierFly(bFlying) {
var unit = Players.GetLocalPlayerPortraitUnit();
var container = $("#UnitItemContainer" + unit.toString());
if (container) {
var CourierSelectorContainer = container.FindChildTraverse("CourierSelectorContainer");
var itemDef = CourierSelectorContainer.itemDef;
var itemStyle = CourierSelectorContainer.itemStyle;
var bDire = CourierSelectorContainer.bDire;
SwitchCourier(itemDef, itemStyle, bFlying, bDire)();
}
}
// 切æ¢å®ˆå«é—包
function SwitchWard(itemDef, itemStyle) {
return function () {
$.Msg('SwitchWard ', itemDef, ' ', itemStyle);
var unit = Players.GetLocalPlayerPortraitUnit();
var container = $("#UnitItemContainer" + unit.toString());
if (!itemStyle) {
itemStyle = 0;
}
SendEventToServerWithCallback(
"SwitchWard",
{
"unit": unit,
"itemDef": itemDef,
"itemStyle": itemStyle,
},
function (params) {
Game.EmitSound('DOTA_Item.ObserverWard.Activate');
var slotName = "ward";
if (container) {
var EquipContainer = container.FindChildTraverse("EquipItemContainer");
var EconItemSlot = EquipContainer.FindChildTraverse(slotName);
if (EconItemSlot) {
var EconItem = GetEconItem(EconItemSlot);
var StyleMenu = $("#" + EconItem.id + "StyleMenu");
EconItem.DeleteAsync(0);
if (StyleMenu) {
StyleMenu.DeleteAsync(0);
}
var uid = GetUniqueID();
var econItemText = '<DOTAEconItem id="' + uid + '" class="DisableInspect" itemdef="' + itemDef + '" onload="SetEconItemButtons(\'' + uid + '\', \'' + itemDef + '\', ' + itemStyle + ')" />';
EconItemSlot.BCreateChildren(econItemText);
}
}
}
);
}
};
function CreateSelectCosmeticsForUnit(unit) {
var origin_unit = ID_Map[unit] || unit;
$.Msg("CreateSelectCosmeticsForUnit", origin_unit, ' ', unit);
var container = $.CreatePanel("Panel", $("#HeroInspectBackground"), "UnitItemContainer" + origin_unit.toString());
container.BLoadLayoutSnippet("EconItemContainer");
var EquipContainer = container.FindChildTraverse("EquipItemContainer");
var AvailableItemsCarousel = container.FindChildTraverse("AvailableItemsCarousel");
if (IsWearableUnit(unit)) {
var Wearables = CustomNetTables.GetTableValue("hero_wearables", unit.toString());
var AvailableItems = CustomNetTables.GetTableValue("hero_available_items", GetUnitName(unit));
// 创建æ†ç»‘包å¯æ›´æ¢è£…备æ
if (AvailableItems && AvailableItems["bundles"]) {
var Bundles = AvailableItems["bundles"];
var BundlePanel = $.CreatePanel("DelayLoadPanel", AvailableItemsCarousel, "bundle");
BundlePanel.AddClass("CarouselPage");
for (var k in Bundles) {
var storeItemDef = Bundles[k];
var storeItemID = "StoreItem" + storeItemDef;
var storeItemText = '<DOTAStoreItem id="' + storeItemID + '" itemdef="' + storeItemDef + '" onactivate="SwitchWearable(' + storeItemDef + ')()" />';
BundlePanel.BCreateChildren(storeItemText);
var StoreItem = BundlePanel.FindChildTraverse(storeItemID);
// 饰å“图片会挡ä½çˆ¶é¢æ¿çš„点击事件，但åˆéœ€è¦å®ƒçš„tooltip，ä¸èƒ½å…³é—hittest
var ItemImage = StoreItem.FindChildTraverse("ItemImage");
ItemImage.SetPanelEvent("onactivate", SwitchWearable(storeItemDef));
}
EquipContainer.SetPanelEvent("onactivate", SelectSlot(null, BundlePanel));
var BundleButton = container.FindChildTraverse("Bundle");
BundleButton.SetPanelEvent("onactivate", SelectSlot(null, BundlePanel));
}
var SlotArray = SortSlots(AvailableItems);
for (var slotIndex = 0; slotIndex < SlotArray.length; slotIndex++) {
var Slot = SlotArray[slotIndex];
if (Slot.DisplayInLoadout == 0) {
continue;
}
var slotName = Slot.SlotName;
var EquipedItem = Wearables[slotName];
if (!EquipedItem) {
continue;
}
var equipedItemDef = EquipedItem["itemDef"];
var equipedItemStyle = EquipedItem["style"];
// 创建å•ä¸€æ§½ä½æ ¼
var EconItemSlot = $.CreatePanel("Panel", EquipContainer, slotName);
EconItemSlot.BLoadLayoutSnippet("EconItemSlot");
var SlotLabel = EconItemSlot.FindChildTraverse("SlotName");
SlotLabel.text = $.Localize(Slot.SlotText);
var uid = GetUniqueID();
var econItemText = '<DOTAEconItem id="' + uid + '" class="DisableInspect" itemdef="' + equipedItemDef
+ '" onload="SetEconItemButtons(\'' + uid + '\', \'' + equipedItemDef + '\', ' + equipedItemStyle + ')"'
+ ' oncontextmenu="ShowDetailButton(\'' + uid + '\', \'' + equipedItemDef + '\', ' + equipedItemStyle + ')" />';
EconItemSlot.BCreateChildren(econItemText);
// 创建该槽ä½å¯æ›´æ¢è£…备æ
var DelayLoadPanel = $.CreatePanel("DelayLoadPanel", AvailableItemsCarousel, slotName);
DelayLoadPanel.AddClass("CarouselPage");
for (var k in Slot["ItemDefs"]) {
var storeItemDef = Slot["ItemDefs"][k];
var storeItemID = "StoreItem" + storeItemDef;
var storeItemText = '<DOTAStoreItem id="' + storeItemID + '" itemdef="' + storeItemDef + '" onactivate="SwitchWearable(' + storeItemDef + ')()" />';
DelayLoadPanel.BCreateChildren(storeItemText);
var StoreItem = DelayLoadPanel.FindChildTraverse(storeItemID);
// 饰å“图片会挡ä½çˆ¶é¢æ¿çš„点击事件，但åˆéœ€è¦é¼ æ ‡åœç•™æ—¶å®ƒçš„tooltip，ä¸èƒ½å…³é—hittest
var ItemImage = StoreItem.FindChildTraverse("ItemImage");
ItemImage.SetPanelEvent("onactivate", SwitchWearable(storeItemDef));
}
DelayLoadPanel.SetHasClass("Hidden", true);
EconItemSlot.SetPanelEvent("onactivate", SelectSlot(EconItemSlot, DelayLoadPanel));
}
} else if (IsCourier(unit)) {
var AvailableItems = CustomNetTables.GetTableValue("other_available_items", "courier");
var slotName = "courier";
// 创建å•ä¸€æ§½ä½æ ¼
var EconItemSlot = $.CreatePanel("Panel", EquipContainer, slotName);
EconItemSlot.BLoadLayoutSnippet("EconItemSlot");
var SlotLabel = EconItemSlot.FindChildTraverse("SlotName");
SlotLabel.text = $.Localize("DOTA_GlobalItems_Couriers");
var uid = GetUniqueID();
var equipedItemDef = "595";
var equipedItemStyle = 0;
var econItemText = '<DOTAEconItem id="' + uid + '" class="DisableInspect" itemdef="' + equipedItemDef
+ '" onload="SetEconItemButtons(\'' + uid + '\', \'' + equipedItemDef + '\', ' + equipedItemStyle + ')"'
+ ' oncontextmenu="ShowDetailButton(\'' + uid + '\', \'' + equipedItemDef + '\', ' + equipedItemStyle + ')" />';
EconItemSlot.BCreateChildren(econItemText);
// 创建队ä¼å’Œé£žè¡Œé€‰æ‹©å™¨
var CourierSelectorContainer = $.CreatePanel("Panel", EquipContainer, "CourierSelectorContainer");
CourierSelectorContainer.BLoadLayoutSnippet("CourierSelectorContainer");
CourierSelectorContainer.itemDef = equipedItemDef;
CourierSelectorContainer.itemStyle = equipedItemStyle;
CourierSelectorContainer.bFlying = false;
CourierSelectorContainer.bDire = false;
// 创建å¯æ›´æ¢è£…备æ
var DelayLoadPanel = $.CreatePanel("DelayLoadPanel", AvailableItemsCarousel, "courier");
DelayLoadPanel.AddClass("CarouselPage");
for (var storeItemDef in AvailableItems) {
var storeItemID = "StoreItem" + storeItemDef;
var storeItemText = '<DOTAStoreItem id="' + storeItemID + '" itemdef="' + storeItemDef + '" onactivate="SwitchCourier(' + storeItemDef + ')()" />';
DelayLoadPanel.BCreateChildren(storeItemText);
var StoreItem = DelayLoadPanel.FindChildTraverse(storeItemID);
// 饰å“图片会挡ä½çˆ¶é¢æ¿çš„点击事件，但åˆéœ€è¦é¼ æ ‡åœç•™æ—¶å®ƒçš„tooltip，ä¸èƒ½å…³é—hittest
var ItemImage = StoreItem.FindChildTraverse("ItemImage");
ItemImage.SetPanelEvent("onactivate", SwitchCourier(storeItemDef));
}
} else if (Entities.IsWard(unit)) {
var AvailableItems = CustomNetTables.GetTableValue("other_available_items", "ward");
var slotName = "ward";
// 创建å•ä¸€æ§½ä½æ ¼
var EconItemSlot = $.CreatePanel("Panel", EquipContainer, slotName);
EconItemSlot.BLoadLayoutSnippet("EconItemSlot");
var SlotLabel = EconItemSlot.FindChildTraverse("SlotName");
SlotLabel.text = $.Localize("DOTA_GlobalItems_Wards");
var uid = GetUniqueID();
var equipedItemDef = "596";
var equipedItemStyle = 0;
var econItemText = '<DOTAEconItem id="' + uid + '" class="DisableInspect" itemdef="' + equipedItemDef
+ '" onload="SetEconItemButtons(\'' + uid + '\', \'' + equipedItemDef + '\', ' + equipedItemStyle + ')"'
+ ' oncontextmenu="ShowDetailButton(\'' + uid + '\', \'' + equipedItemDef + '\', ' + equipedItemStyle + ')" />';
EconItemSlot.BCreateChildren(econItemText);
// 创建å¯æ›´æ¢è£…备æ
var DelayLoadPanel = $.CreatePanel("DelayLoadPanel", AvailableItemsCarousel, "ward");
DelayLoadPanel.AddClass("CarouselPage");
for (var storeItemDef in AvailableItems) {
var storeItemID = "StoreItem" + storeItemDef;
var storeItemText = '<DOTAStoreItem id="' + storeItemID + '" itemdef="' + storeItemDef + '" onactivate="SwitchWard(' + storeItemDef + ')()" />';
DelayLoadPanel.BCreateChildren(storeItemText);
var StoreItem = DelayLoadPanel.FindChildTraverse(storeItemID);
// 饰å“图片会挡ä½çˆ¶é¢æ¿çš„点击事件，但åˆéœ€è¦é¼ æ ‡åœç•™æ—¶å®ƒçš„tooltip，ä¸èƒ½å…³é—hittest
var ItemImage = StoreItem.FindChildTraverse("ItemImage");
ItemImage.SetPanelEvent("onactivate", SwitchWard(storeItemDef));
}
} else {
EquipContainer.SetHasClass("NotWearable", true);
}
}
function SetEconItemButtons(econItemID, itemDef, itemStyle) {
var EconItem = $("#" + econItemID);
var EconItemSlot = EconItem.GetParent()
var slotName = EconItemSlot.id
var position = EconItemSlot.GetPositionWithinWindow();
var x = position.x / EconItemSlot.actualuiscale_x
var y = (position.y + EconItemSlot.actuallayoutheight) / EconItemSlot.actualuiscale_y;
if (itemStyle === undefined) {
itemStyle = 0;
}
var MultiStyle = EconItem.FindChildTraverse("MultiStyle");
if (MultiStyle.visible) {
var unit = Players.GetLocalPlayerPortraitUnit();
var imageSrc = null;
var AvailableStylesList = null
if (IsWearableUnit(unit)) {
var AvailableItems = CustomNetTables.GetTableValue("hero_available_items", GetUnitName(unit));
AvailableStylesList = AvailableItems[slotName]["styles"][itemDef];
} else if (IsCourier(unit)) {
var AvailableItems = CustomNetTables.GetTableValue("other_available_items", "courier");
AvailableStylesList = AvailableItems[itemDef]["styles"];
} else if (Entities.IsWard(unit)) {
var AvailableItems = CustomNetTables.GetTableValue("other_available_items", "ward");
AvailableStylesList = AvailableItems[itemDef]["styles"];
}
if (AvailableStylesList
&& AvailableStylesList[itemStyle.toString()]
&& AvailableStylesList[itemStyle.toString()].icon_path) {
imageSrc = "s2r://panorama/images/" + AvailableStylesList[itemStyle.toString()].icon_path + "_png.vtex";
}
var SelectStyle = MultiStyle.FindChildTraverse("MultiStyleSelectedStyle");
var total = SelectStyle.text.split('/')[1];
SelectStyle.text = (itemStyle + 1).toString() + "/" + total;
var StyleMenu = $.CreatePanel("Panel", $.GetContextPanel(), econItemID + "StyleMenu");
StyleMenu.BLoadLayoutSnippet("EconItemStyleContextMenu");
var EconItemIcon = EconItem.FindChildTraverse("EconItemIcon");
if (imageSrc) {
EconItemIcon.SetImage(imageSrc);
}
StyleMenu.SetPositionInPixels(x, y, 0);
var StylesList = StyleMenu.FindChildTraverse("StylesList");
for (var iStyle = 0; iStyle < parseInt(total); iStyle++) {
var StyleEntry = $.CreatePanel("Panel", StylesList, "");
StyleEntry.BLoadLayoutSnippet("StyleEntry");
if (iStyle == itemStyle) {
StyleEntry.AddClass("Selected");
} else {
StyleEntry.AddClass("Available");
if (IsCourier(unit)) {
StyleEntry.SetPanelEvent("onactivate", SwitchCourier(itemDef, iStyle));
} else if (Entities.IsWard(unit)) {
StyleEntry.SetPanelEvent("onactivate", SwitchWard(itemDef, iStyle));
} else {
StyleEntry.SetPanelEvent("onactivate", SwitchWearable(itemDef, iStyle));
}
}
if (AvailableStylesList
&& AvailableStylesList[iStyle.toString()]
&& AvailableStylesList[iStyle.toString()].name) {
var StyleLabel = StyleEntry.FindChildTraverse("StyleLabel");
StyleLabel.text = $.Localize(AvailableStylesList[iStyle.toString()].name)
}
}
MultiStyle.SetPanelEvent("onactivate", ToggleStyleMenu(StyleMenu));
}
EconItem.SetPanelEvent("oncontextmenu", function () {
var contextMenu = $.CreatePanel("ContextMenuScript", $.GetContextPanel(), "");
contextMenu.AddClass("ContextMenu_NoArrow");
contextMenu.AddClass("ContextMenu_NoBorder");
contextMenu.GetContentsPanel().itemDef = itemDef;
contextMenu.GetContentsPanel().itemStyle = itemStyle;
contextMenu.GetContentsPanel().BLoadLayout("file://{resources}/layout/custom_game/econ_item_context_menu.xml", false, false);
contextMenu.GetContentsPanel().SetFocus();
})
var TeamSelectorContainer = EconItemSlot.GetParent().FindChildTraverse("TeamSelectorContainer");
if (TeamSelectorContainer) {
if (EconItem.BHasClass("HasTeamSpecificViews")) {
TeamSelectorContainer.SetHasClass("Hidden", false);
} else {
TeamSelectorContainer.SetHasClass("Hidden", true);
}
}
}
*/
function SortSlots(AvailableItems) {
var SlotArray = [];
for (var slotName in AvailableItems) {
var Slot = AvailableItems[slotName];
Slot.SlotName = slotName;
var slotIndex = Slot.SlotIndex;
if (slotIndex === undefined) {
continue;
}
var i = 0
for (var i = 0; i < SlotArray.length; i++) {
if (slotIndex < SlotArray[i].SlotIndex) {
break;
}
}
SlotArray.splice(i, 0, Slot);
}
return SlotArray;
}
/*
function ToggleSelectCosmetics() {
$('#SelectCosmeticsContainer').ToggleClass('CosmeticsContainerVisible');
if (!$('#SelectCosmeticsContainer').BHasClass('CosmeticsContainerVisible')) {
ResetCamera();
var children = $("#HeroInspectBackground").Children();
for (var child of children) {
child.SetHasClass("Hidden", true);
}
} else {
ZoomInCamera();
var unit = Players.GetLocalPlayerPortraitUnit();
var origin_unit = ID_Map[unit] || unit;
var container = $("#UnitItemContainer" + origin_unit.toString());
if (container === null) {
CreateSelectCosmeticsForUnit(unit);
} else {
container.SetHasClass("Hidden", false);
}
}
}
*/
function ToggleStyleMenu(StyleMenu) {
return function () {
StyleMenu.ToggleClass("Hidden");
}
}
function Taunt() {
var unit = Players.GetLocalPlayerPortraitUnit();
GameEvents.SendCustomGameEventToServer("Taunt", { "unit": unit });
}
function SelectAndLookUnit(unit) {
if (Entities.IsValidEntity(unit)) {
var position = Entities.GetAbsOrigin(unit);
GameUI.SelectUnit(unit, false);
if (!ZoomInMode) {
GameUI.SetCameraTargetPosition(position, 0.5);
} else {
ZoomInCamera();
}
} else {
$.Schedule(FRAME_TIME * 10, function () {
SelectAndLookUnit(unit);
})
}
}
function AllyRemoved(data) {
var unit = ID_Map[data.unit] || data.unit;
var container = $("#UnitItemContainer" + unit.toString());
if (container) {
container.DeleteAsync(FRAME_TIME);
}
$("#Hero" + unit.toString()).DeleteAsync(FRAME_TIME);
}
function CopySelection() {
var unit = Players.GetLocalPlayerPortraitUnit();
GameEvents.SendCustomGameEventToServer("CopySelection", { "unit": unit });
}
function AllySpawned(data) {
$.Msg(data)
var unit = data.unit;
if (Entities.IsValidEntity(unit)) {
SelectAndLookUnit(unit);
var HeroItemText = '<Panel id="Hero' + unit.toString() + '" class="HeroImageItem" onactivate="SelectAndLookUnit(' + unit + ')">' +
'<DOTAHeroImage id="HeroImage" class="TopBarHeroImage" heroname="' + GetHeroName(unit) + '" heroimagestyle="landscape" />'
+ '</Panel>';
$("#HeroImageContainer").BCreateChildren(HeroItemText);
} else {
$.Schedule(FRAME_TIME * 10, function () {
AllySpawned(data);
})
}
}
function GetEconItem(EconItemSlot) {
var EconItem;
for (var child of EconItemSlot.Children()) {
if (child.paneltype == "DOTAEconItem") {
EconItem = child;
}
}
return EconItem
}
/*
function UpdateWearable(params) {
// $.Msg("UpdateWearable ", params);
Game.EmitSound('inventory.wear');
var unit_id = params.unit;
unit_id = ID_Map[unit_id] || unit_id;
var itemDef = params.itemDef;
var slotName = params.slotName;
var itemStyle = params.itemStyle;
var container = $("#UnitItemContainer" + unit_id.toString());
if (container) {
var EquipContainer = container.FindChildTraverse("EquipItemContainer");
var EconItemSlot = EquipContainer.FindChildTraverse(slotName);
if (EconItemSlot) {
var EconItem = GetEconItem(EconItemSlot);
var StyleMenu = $("#" + EconItem.id + "StyleMenu");
EconItem.DeleteAsync(0);
if (StyleMenu) {
StyleMenu.DeleteAsync(0);
}
var uid = GetUniqueID();
var econItemText = '<DOTAEconItem id="' + uid + '" class="DisableInspect" itemdef="' + itemDef + '" onload="SetEconItemButtons(\'' + uid + '\', \'' + itemDef + '\', ' + itemStyle + ')" />';
EconItemSlot.BCreateChildren(econItemText);
}
}
}
*/
function RespawnWear(data) {
$.Msg("RespawnWear ", data);
var old_unit = data.old_unit;
var new_unit = data.new_unit;
var item = data.item;
var bundle = data.bundle;
ID_Map[new_unit] = old_unit;
SelectAndLookUnit(new_unit);
var HeroImagePanel = $("#Hero" + old_unit.toString());
HeroImagePanel.SetPanelEvent("onactivate", function () {
SelectAndLookUnit(new_unit);
});
/*
if (bundle) {
for (var i in bundle) {
var subItem = bundle[i];
UpdateWearable(subItem);
}
} else {
UpdateWearable(item);
}
*/
}
/*
function OnSelectionChangeForCosmetics(unit, old_unit) {
if ($('#SelectCosmeticsContainer').BHasClass('CosmeticsContainerVisible')) {
if (old_unit) {
var originID = ID_Map[old_unit] || old_unit;
var CurrentCosmeticsContainer = $("#UnitItemContainer" + originID.toString());
if (CurrentCosmeticsContainer) {
CurrentCosmeticsContainer.SetHasClass("Hidden", true);
}
}
var originID = ID_Map[unit] || unit;
var CosmeticsContainer = $("#UnitItemContainer" + originID.toString());
if (CosmeticsContainer === null) {
CreateSelectCosmeticsForUnit(unit);
} else {
CosmeticsContainer.SetHasClass("Hidden", false);
}
ZoomInCamera();
}
}
*/
function ShowDemoPanel() {
// $.Msg("Enter Function ShowDemoPanel");
$.GetContextPanel().FindChildTraverse('ControlPanel').AddClass("visible");
}
(function () {
$.RegisterEventHandler('DOTAUIHeroPickerHeroSelected', $('#SelectEnemyHeroContainer'), SpawnEnemyNewHero);
$.RegisterEventHandler('DOTAUIHeroPickerHeroSelected', $('#SelectAllyHeroContainer'), SpawnAllyNewHero);
// GameEvents.Subscribe('UpdateWearable', UpdateWearable);
GameEvents.Subscribe('AllySpawned', AllySpawned);
GameEvents.Subscribe('AllyRemoved', AllyRemoved);
GameEvents.Subscribe('RespawnWear', RespawnWear);
GameEvents.Subscribe('ShowDemoPanel', ShowDemoPanel);
ID_Map = {};
// $('#SelectAllyHeroContainer').SetHasClass("HeroPickerVisible", true);
// GetUniqueID = UniqueIDClosure();
// RegisterSelectionChange(OnSelectionChangeForCosmetics);
})();
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/raikage/raikage_speed_blitz.ts
|
<reponame>jaden-young/NWR
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class raikage_speed_blitz extends BaseAbility {
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("soundfile", "soundevents/heroes/raikage/game_sounds_raikage.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/raikage/game_sounds_vo_raikage.vsndevts", context);
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
caster.AddNewModifier(caster, this, "modifier_raikage_speed_blitz", {duration: this.GetSpecialValueFor("duration")});
EmitSoundOn("Hero_Raikage.SpeedBlitz.Cast", caster);
}
}
@registerModifier()
export class modifier_raikage_speed_blitz extends BaseModifier
{
bonus_damage?: number;
bonus_move_speed?: number;
damage_table?: ApplyDamageOptions;
slow_duration?: number;
radius?: number;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: Object): void {
let parent = this.GetParent();
let ability = this.GetAbility()!;
this.bonus_damage = ability.GetSpecialValueFor("bonus_damage");
this.bonus_move_speed = ability.GetSpecialValueFor("bonus_move_speed");
this.slow_duration = ability.GetSpecialValueFor("slow_duration");
this.radius = ability.GetSpecialValueFor("radius");
if (!IsServer()) return;
let left_hand_fx = ParticleManager.CreateParticle("particles/econ/items/spirit_breaker/spirit_breaker_thundering_flail/spirit_breaker_thundering_flail.vpcf", ParticleAttachment.CUSTOMORIGIN, parent);
ParticleManager.SetParticleControlEnt(left_hand_fx, 0, parent, ParticleAttachment.POINT_FOLLOW, "attach_lefthand", parent.GetAbsOrigin(), true)
this.AddParticle(left_hand_fx, false, false, -1, false, false);
let right_hand_fx = ParticleManager.CreateParticle("particles/econ/items/spirit_breaker/spirit_breaker_thundering_flail/spirit_breaker_thundering_flail.vpcf", ParticleAttachment.CUSTOMORIGIN, parent);
ParticleManager.SetParticleControlEnt(right_hand_fx, 0, parent, ParticleAttachment.POINT_FOLLOW, "attach_righthand", parent.GetAbsOrigin(), true)
this.AddParticle(right_hand_fx, false, false, -1, false, false);
this.damage_table = {
attacker: parent,
victim: parent,
damage: this.bonus_damage,
damage_type: ability.GetAbilityDamageType(),
ability: ability
}
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.MOVESPEED_BONUS_CONSTANT,
ModifierFunction.TRANSLATE_ACTIVITY_MODIFIERS,
ModifierFunction.ON_ATTACK_LANDED
]}
/****************************************/
GetModifierMoveSpeedBonus_Constant(): number {
return this.bonus_move_speed!;
}
/****************************************/
GetActivityTranslationModifiers(): string {
return "speedblitz";
}
/****************************************/
OnAttackLanded(event: ModifierAttackEvent): void {
if (!IsServer()) return;
let attacker = event.attacker;
let target = event.target;
let ability = this.GetAbility();
if (attacker != this.GetParent() || !ability || !target) return;
let enemies = FindUnitsInRadius(
attacker.GetTeamNumber(),
target.GetAbsOrigin(),
undefined,
this.radius!,
UnitTargetTeam.ENEMY,
UnitTargetType.BASIC + UnitTargetType.HERO,
UnitTargetFlags.NONE,
FindOrder.ANY,
false
);
enemies.forEach(enemy => {
this.damage_table!.victim = enemy;
ApplyDamage(this.damage_table!);
enemy.AddNewModifier(attacker, ability, "modifier_raikage_speed_blitz_debuff", {duration: this.slow_duration! * (1 - enemy.GetStatusResistance())});
});
EmitSoundOn("Hero_Raikage.SpeedBlitz.Impact", attacker);
this.Destroy();
}
}
@registerModifier()
export class modifier_raikage_speed_blitz_debuff extends BaseModifier
{
attack_speed_reduction?: number;
/****************************************/
OnCreated(params: object): void {
this.attack_speed_reduction = -this.GetAbility()!.GetSpecialValueFor("attack_speed_reduction");
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.ATTACKSPEED_BONUS_CONSTANT
]}
/****************************************/
GetModifierAttackSpeedBonus_Constant(): number {
return this.attack_speed_reduction!;
}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/hero_razor/razor_ambient_g.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN_FOLLOW;
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/shisui/shisui_innate_passive.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class shisui_innate_passive extends BaseAbility
{
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("soundfile", "soundevents/heroes/shisui/game_sounds_shisui.vsndevts", context);
}
GetIntrinsicModifierName(): string {
return "modifier_shisui_innate_passive"
}
/****************************************/
Spawn(): void {
if (IsServer()) {
this.SetLevel(1);
}
}
/****************************************/
GetCooldown(level: number): number {
return super.GetCooldown(level) - (this.GetCaster().GetLevel() - 1) * this.GetSpecialValueFor("cd_reduction_lvl");
}
}
@registerModifier()
export class modifier_shisui_innate_passive extends BaseModifier
{
action_cd_reduction?: number;
/****************************************/
IsHidden(): boolean {return true}
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return false}
/****************************************/
OnCreated(params: object): void {
let ability = this.GetAbility()!;
this.action_cd_reduction = ability.GetSpecialValueFor("action_cd_reduction");
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.INCOMING_DAMAGE_PERCENTAGE,
ModifierFunction.ON_ABILITY_EXECUTED,
ModifierFunction.PROCATTACK_FEEDBACK
]}
/****************************************/
GetModifierIncomingDamage_Percentage(event: ModifierAttackEvent): number {
if (!IsServer()) return 0;
let ability = this.GetAbility();
if (this.GetParent().PassivesDisabled() || !ability!.IsCooldownReady()) return 0
ability?.UseResources(true, false, true);
EmitSoundOn("Hero_Shisui.BodyFlicker.Trigger", this.GetParent());
let warp_fx = ParticleManager.CreateParticle("particles/units/heroes/sasuke/sasuke_sharingan_dodge.vpcf", ParticleAttachment.ABSORIGIN_FOLLOW, this.GetParent());
ParticleManager.SetParticleControlEnt(warp_fx, 0, this.GetParent(), ParticleAttachment.POINT_FOLLOW, "attach_hitloc", Vector(0, 0, 0), true);
ParticleManager.ReleaseParticleIndex(warp_fx);
return -100
}
/****************************************/
OnAbilityExecuted(event: ModifierAbilityEvent): void {
if (!IsServer()) return
let unit = event.unit;
let ability = this.GetAbility() as CDOTABaseAbility;
if (unit != this.GetParent() || ability.IsCooldownReady()) return;
let cd = ability.GetCooldownTimeRemaining();
ability.EndCooldown()
ability.StartCooldown(cd - this.action_cd_reduction!);
}
/****************************************/
GetModifierProcAttack_Feedback(event: ModifierAttackEvent): number {
if (!IsServer()) return 0;
this.CheckBodyFlicker()
this.CheckHaloDance();;
return 0;
}
/****************************************/
CheckBodyFlicker(): void {
let ability = this.GetAbility() as CDOTABaseAbility;
if (ability.IsCooldownReady()) return;
let cd = ability.GetCooldownTimeRemaining();
ability.EndCooldown()
ability.StartCooldown(cd - this.action_cd_reduction!);
}
/****************************************/
CheckHaloDance(): void {
let parent = this.GetParent()
if (parent.HasTalent("special_bonus_shisui_6")) {
let halo_dance = parent.FindAbilityByName("shisui_halo_dance")
if (!halo_dance || halo_dance.IsCooldownReady()) return;
let cd = halo_dance.GetCooldownTimeRemaining();
halo_dance.EndCooldown()
halo_dance.StartCooldown(cd - parent.FindTalentValue("special_bonus_shisui_6"));
}
}
}
|
jaden-young/NWR
|
src/panorama/vanilla_hero_selection_override.ts
|
<filename>src/panorama/vanilla_hero_selection_override.ts<gh_stars>0
//@ts-nocheck
var Parent = $.GetContextPanel().GetParent().GetParent().GetParent();
var TooltipHeroMovie, TooltipHeroName, HeroCardTooltip;
var fully_init = false;
function SetSelectionImages(bSetWebms) {
var Container = Parent.FindChildTraverse("GridCategories");
if (Container.GetChildCount() == 0) {
$.Schedule(0.03, SetSelectionImages);
return;
}
for (var i = 0; i < Container.GetChildCount(); i++) {
var child_container = Container.GetChild(i).FindChildTraverse("HeroList");
for (var j = 0; j < child_container.GetChildCount(); j++) {
var button = child_container.GetChild(j);
var image = button.FindChildTraverse("HeroImage");
if (image)
image.SetImage(`file://{images}/custom_game/heroes/selection/npc_dota_hero_${image.heroname}.png`);
if (bSetWebms && bSetWebms == true) {
if (button) {
(function (button, hero_name) {
SetWebmPanels(button, hero_name);
})(button, image.heroname);
}
}
}
}
}
function OnUpdateHeroSelection() {
var localPlayerInfo = Game.GetLocalPlayerInfo();
if ( !localPlayerInfo )
return;
UpdatePortrait(localPlayerInfo.possible_hero_selection);
GameEvents.SendCustomGameEventToAllClients("update_hero_selection_topbar", {
iPlayerID: Game.GetLocalPlayerID(),
iTeamNumber: localPlayerInfo.player_team_id,
sHeroName: localPlayerInfo.possible_hero_selection,
});
}
function UpdatePortrait(sHeroName) {
var PortraitContainer = Parent.FindChildTraverse("HeroPortrait");
if (PortraitContainer) {
PortraitContainer.GetChild(0).style.backgroundImage = 'url("file://{resources}/images/custom_game/heroes/selection/npc_dota_hero_' + sHeroName + '.png")';
PortraitContainer.GetChild(0).style.backgroundSize = "cover";
if (Parent.FindChildTraverse("CustomHeroMoviePortrait"))
Parent.FindChildTraverse("CustomHeroMoviePortrait").DeleteAsync(0);
var MovieContainer = $.CreatePanel( "Panel", Parent.FindChildTraverse("ImageContainer"), "CustomHeroMovie");
MovieContainer.style.width = "160px";
MovieContainer.style.height = "203px";
MovieContainer.style.boxShadow = "#000000aa 0px 0px 16px 0px";
const MoviePanel = $.CreatePanelWithProperties("MoviePanel", MovieContainer, `CustomHeroMovie_${sHeroName}`, {
src: `s2r://panorama/videos/custom_game/heroes/npc_dota_hero_${sHeroName}.webm`,
autoplay: "onload",
repeat: true,
});
}
}
function UpdateTopBar(data) {
var team = "Radiant";
var loopstart = 0;
var loopend = 5;
var playerInfo = Game.GetPlayerInfo( data.iPlayerID );
if (data.iTeamNumber && data.iTeamNumber == 3) {
team = "Dire";
loopend = 10;
loopstart = 5;
}
var hero_topbar_team = Parent.FindChildTraverse(team + "TeamPlayers");
for (var i = loopstart;i<loopend;i++) {
var slot_panel = hero_topbar_team.FindChildrenWithClassTraverse("Slot" + i)[0]
var name_container = slot_panel.FindChildTraverse("NameContainer");
var player_name_panel = name_container.FindChildTraverse("PlayerNameContainer");
var player_name = player_name_panel.FindChildTraverse("PlayerName");
if (player_name.text === playerInfo.player_name) {
var hero_image = slot_panel.FindChildTraverse("HeroImage") as HeroImage;
if (hero_image) {
hero_image.SetImage('file://{images}/custom_game/heroes/topbar/npc_dota_hero_' + data.sHeroName + '.png');
hero_image.style.backgroundSize = "100% 100%";
}
}
}
}
function SetWebmPanels(button, hero_name) {
var offset_x = -90;
var offset_y = -90;
if (HeroCardTooltip && fully_init == false) {
button.SetPanelEvent("onmouseover", function() {
// $.Msg("Hero Name: " + hero_name)
HeroCardTooltip.SetHasClass("TooltipVisible", false);
var position = button.GetPositionWithinWindow();
HeroCardTooltip.style.transform = 'translateX( ' + (position["x"] + offset_x) + 'px ) translateY( ' + (position["y"] + offset_y) + 'px )';
HeroCardTooltip.SetHasClass("TooltipVisible", true);
TooltipHeroName.text = $.Localize("#npc_dota_hero_" + hero_name).toUpperCase();
const MovieContainer = $.CreatePanel("Panel", Parent.FindChildTraverse("ImageContainer"), `CustomHeroMovieContainer_${hero_name}`);
const MoviePanel = $.CreatePanelWithProperties("MoviePanel", MovieContainer, `CustomHeroMovie_${hero_name}`, {
src: `s2r://panorama/videos/custom_game/heroes/npc_dota_hero_${hero_name}.webm`,
autoplay: "onload",
repeat: true,
});
fully_init = true;
})
button.SetPanelEvent("onmousout", function() {
HeroCardTooltip.SetHasClass("TooltipVisible", false);
if (Parent.FindChildTraverse("CustomHeroMovie"))
Parent.FindChildTraverse("CustomHeroMovie").DeleteAsync(0);
})
}
}
function SetStrategyHeroModel(data) {
var HeroModel = $.CreatePanel("Panel", Parent.FindChildTraverse("EconSetPreview2"), "");
HeroModel.style.width = "100%";
HeroModel.style.height = "100%";
const HeroPanel = $.CreatePanelWithProperties("DOTAScenePanel", HeroModel, "HeroPanel", {
particleonly: false,
unit: data.hero_name,
});
HeroPanel.style.height = "100%";
HeroPanel.style.width = "100%";
// HeroModel.style.opacityMask = 'url("s2r://panorama/images/masks/hero_model_opacity_mask_png.vtex");'
}
function Init() {
if (fully_init == false && Parent.FindChildTraverse("HeroCardTooltip")) {
HeroCardTooltip = Parent.FindChildTraverse("HeroCardTooltip");
TooltipHeroName = HeroCardTooltip.FindChildTraverse("HeroName");
SetSelectionImages(true);
} else {
$.Schedule(0.03, Init);
}
/*
if (Game.IsInToolsMode()) {
while (Parent.FindChildTraverse("CustomHeroMovie") != undefined) {
$.Msg(Parent.FindChildTraverse("CustomHeroMovie"));
if (Parent.FindChildTraverse("CustomHeroMovie"))
Parent.FindChildTraverse("CustomHeroMovie").DeleteAsync(0);
}
}
*/
}
(function() {
GameEvents.Subscribe( "update_hero_selection_topbar", UpdateTopBar );
GameEvents.Subscribe( "dota_player_hero_selection_dirty", OnUpdateHeroSelection );
// GameEvents.Subscribe( "dota_player_update_hero_selection", OnUpdateHeroSelection );
// TODO: look into ScenePanel.SpawnHeroInScenePanel* methods to get this working
GameEvents.Subscribe( "set_strategy_time_hero_model", SetStrategyHeroModel );
SetSelectionImages();
Init();
})();
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/kisame/kisame_exploding_water_shockwave.ts
|
import { BaseAbility, BaseModifier, BaseModifierMotionHorizontal, BaseModifierMotionVertical, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface kv {
handle: ProjectileID;
}
@registerAbility()
export class kisame_exploding_water_shockwave extends BaseAbility
{
/****************************************/
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/kisame/kisame_exploding_water_shockwave.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/kisame/game_sounds_kisame.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/kisame/game_sounds_vo_kisame.vsndevts", context);
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let position = this.GetCursorPosition();
let radius = this.GetSpecialValueFor("wave_radius");
let origin = caster.GetAbsOrigin() - caster.GetForwardVector() * 100 as Vector;
let direction = (position - origin as Vector).Normalized();
let distance = this.GetCastRange(position, undefined) + 100;
let id = ProjectileManager.CreateLinearProjectile({
Ability: this,
EffectName: "particles/units/heroes/kisame/kisame_exploding_water_shockwave.vpcf",
vSpawnOrigin: origin,
fDistance: distance,
fStartRadius: radius,
fEndRadius: radius,
Source: caster,
bHasFrontalCone: true,
iUnitTargetTeam: UnitTargetTeam.ENEMY,
iUnitTargetType: UnitTargetType.BASIC + UnitTargetType.HERO,
vVelocity: direction * this.GetSpecialValueFor("wave_speed") as Vector,
iVisionRadius: radius,
iVisionTeamNumber: caster.GetTeamNumber()
})
caster.AddNewModifier(caster, this, "modifier_kisame_exploding_water_shockwave", {duration: -1, handle: id});
EmitSoundOn("Hero_Kisame.ExplodingWaterShockwave.Cast", caster);
EmitSoundOn("Hero_Kisame.ExplodingWaterShockwave.Target", caster);
}
/****************************************/
OnProjectileHitHandle(target: CDOTA_BaseNPC | undefined, location: Vector, projectileHandle: ProjectileID): boolean | void {
if (!target) return;
let caster = this.GetCaster();
ApplyDamage({
attacker: caster,
victim: target,
damage: this.GetSpecialValueFor("damage"),
damage_type: this.GetAbilityDamageType(),
ability: this
})
target.AddNewModifier(caster, this, "modifier_kisame_exploding_water_shockwave", {duration: -1, handle: projectileHandle});
EmitSoundOn("Hero_Kisame.ExplodingWaterShockwave.Target", target);
}
}
@registerModifier()
export class modifier_kisame_exploding_water_shockwave extends BaseModifierMotionHorizontal
{
projectile?: ProjectileID;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: kv): void {
if (!IsServer()) return;
this.projectile = params.handle;
if (!this.ApplyHorizontalMotionController()) {
this.Destroy();
return;
}
}
/****************************************/
OnDestroy(): void {
if (!IsServer()) return;
this.GetParent().RemoveHorizontalMotionController(this);
}
/****************************************/
UpdateHorizontalMotion(me: CDOTA_BaseNPC, dt: number): void {
if (!ProjectileManager.IsValidProjectile(this.projectile!)) {
this.Destroy();
return;
}
me.SetAbsOrigin(me.GetAbsOrigin() + ProjectileManager.GetLinearProjectileVelocity(this.projectile) * dt as Vector);
}
/****************************************/
OnHorizontalMotionInterrupted(): void {
this.Destroy();
}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {return {[ModifierState.STUNNED]: this.GetParent() != this.GetCaster()}}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/shisui/shisui_great_fireball_technique.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface extra {
sound_eid: EntityIndex
}
@registerAbility()
export class shisui_great_fireball_technique extends BaseAbility {
fast_vo: boolean = false;
/****************************************/
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/sasuke/sasuke_great_fireball_technique_technique.vpcf", context);
PrecacheResource("particle", "particles/units/heroes/sasuke/sasuke_great_fireball_technique_impact.vpcf", context);
PrecacheResource("particle", "particles/units/heroes/sasuke/sasuke_great_fireball_technique_debuff.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/shisui/game_sounds_shisui.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/shisui/game_sounds_vo_shisui.vsndevts", context);
}
/****************************************/
GetIntrinsicModifierName(): string {
return "modifier_shisui_great_fireball_technique_tracker"
}
/****************************************/
GetCastPoint(): number {
let caster = this.GetCaster();
let stacks = caster.GetModifierStackCount(this.GetIntrinsicModifierName(), caster);
return math.max(this.GetSpecialValueFor("min_cast_point"), super.GetCastPoint() - stacks * this.GetSpecialValueFor("cast_time_per_action"));
}
/****************************************/
OnAbilityPhaseStart(): boolean {
let cast_point = tonumber(string.format("%.1f", this.GetCastPoint())) as number
if (cast_point >= 0.5) {
EmitSoundOn("VO_Hero_Shisui.GreatFireball.Precast", this.GetCaster());
} else {
EmitSoundOn("VO_Hero_Shisui.GreatFireball.Fast", this.GetCaster());
this.fast_vo = true;
}
EmitSoundOn("Hero_Shisui.GreatFireball.Precast_" + cast_point, this.GetCaster());
return true;
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let position = this.GetCursorPosition();
let radius = this.GetSpecialValueFor("radius");
let speed = this.GetSpecialValueFor("speed");
let direction = position - caster.GetAbsOrigin() as Vector;
direction.z = 0;
direction = direction.Normalized();
let sound_ent = CreateModifierThinker(caster, this, "", {}, caster.GetAbsOrigin(), caster.GetTeamNumber(), false);
EmitSoundOn("Hero_Shisui.GreatFireball.Cast", sound_ent);
if (!this.fast_vo) EmitSoundOn("VO_Hero_Shisui.GreatFireball.Cast", caster);
this.fast_vo = false;
ProjectileManager.CreateLinearProjectile({
Ability: this,
EffectName: "particles/units/heroes/sasuke/sasuke_great_fireball_technique.vpcf",
vSpawnOrigin: caster.GetAttachmentOrigin(caster.ScriptLookupAttachment("attach_mouth")) as Vector,
fDistance: this.GetEffectiveCastRange(position, caster),
Source: caster,
fStartRadius: radius,
fEndRadius: radius,
iUnitTargetTeam: UnitTargetTeam.ENEMY,
iUnitTargetType: UnitTargetType.BASIC + UnitTargetType.HERO,
iUnitTargetFlags: UnitTargetFlags.NONE,
vVelocity: direction * speed as Vector,
ExtraData: {
sound_eid: sound_ent.entindex()
}
});
}
/****************************************/
OnProjectileThink_ExtraData(location: Vector, extraData: extra): void {
let sound_ent = EntIndexToHScript(extraData.sound_eid);
if (!sound_ent || sound_ent.IsNull()) return;
sound_ent.SetAbsOrigin(location);
}
/****************************************/
OnProjectileHit_ExtraData(target: CDOTA_BaseNPC | undefined, location: Vector, extraData: extra): boolean | void {
if (!target || !this || this.IsNull()) {
let sound_ent = EntIndexToHScript(extraData.sound_eid);
if (!sound_ent || sound_ent.IsNull()) return;
UTIL_Remove(sound_ent)
return;
}
let caster = this.GetCaster();
let damage_table : ApplyDamageOptions = {
attacker: caster,
victim: target,
damage: this.GetSpecialValueFor("damage"),
damage_type: this.GetAbilityDamageType(),
ability: this
}
ApplyDamage(damage_table);
target.AddNewModifier(caster, this, "modifier_shisui_great_fireball_technique", {duration: this.GetSpecialValueFor("duration") * (1 - target.GetStatusResistance())});
ParticleManager.ReleaseParticleIndex(
ParticleManager.CreateParticle("particles/units/heroes/sasuke/sasuke_great_fireball_technique_impact.vpcf", ParticleAttachment.ABSORIGIN, target)
);
EmitSoundOn("Hero_Shisui.GreatFireball.Impact", target);
}
}
@registerModifier()
export class modifier_shisui_great_fireball_technique extends BaseModifier
{
move_slow?: number;
burn_damage?: number;
damage_table?: ApplyDamageOptions;
/****************************************/
OnCreated(params: object): void {
let ability = this.GetAbility()!;
this.move_slow = -ability.GetSpecialValueFor("move_slow");
this.burn_damage = ability.GetSpecialValueFor("burn_damage") + this.GetCaster()!.FindTalentValue("special_bonus_shisui_3");
let interval = ability.GetSpecialValueFor("dps_interval");
if (!IsServer()) return;
this.damage_table = {
attacker: this.GetCaster()!,
victim: this.GetParent(),
damage: this.burn_damage * interval,
damage_type: this.GetAbility()?.GetAbilityDamageType()!,
ability: this.GetAbility()
}
this.StartIntervalThink(interval);
this.OnIntervalThink();
}
/****************************************/
OnIntervalThink(): void {
ApplyDamage(this.damage_table!);
SendOverheadEventMessage(undefined, OverheadAlert.BONUS_SPELL_DAMAGE, this.GetParent(), this.damage_table!.damage, undefined);
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.MOVESPEED_BONUS_PERCENTAGE,
]}
/****************************************/
GetModifierMoveSpeedBonus_Percentage(): number {
return this.move_slow!;
}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/sasuke/sasuke_great_fireball_technique_debuff.vpcf"
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN_FOLLOW
}
}
@registerModifier()
export class modifier_shisui_great_fireball_technique_tracker extends BaseModifier
{
action_window?: number;
current_stacks?: number;
max_stacks?: number;
cast_time_per_action?: number;
last_reset: number = -1;
activity?: string;
castpoint_activies: any = {
[0]: "",
[2]: "slow",
[4]: "fast",
[6]: "faster",
[8]: "superfast"
}
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return false}
IsHidden(): boolean {return this.GetStackCount() == 0}
/****************************************/
OnCreated(params: object): void {
let ability = this.GetAbility();
let base_cast_point = ability?.GetSpecialValueFor("cast_point")!;
let min_cast_point = ability?.GetSpecialValueFor("min_cast_point")!
this.action_window = ability?.GetSpecialValueFor("action_window");
this.cast_time_per_action = ability?.GetSpecialValueFor("cast_time_per_action")!;
this.max_stacks = math.floor(((base_cast_point - min_cast_point) / this.cast_time_per_action) + 0.5);
this.current_stacks = 0;
this.activity = this.castpoint_activies[this.current_stacks];
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.ON_ATTACK_LANDED,
ModifierFunction.ON_ABILITY_EXECUTED,
ModifierFunction.TRANSLATE_ACTIVITY_MODIFIERS,
ModifierFunction.TOOLTIP
]}
/****************************************/
OnAttackLanded(event: ModifierAttackEvent): void {
if (!IsServer()) return;
this.UpdateStacks(event.attacker);
}
/****************************************/
OnAbilityExecuted(event: ModifierAbilityEvent): void {
if (!IsServer()) return;
let ability = event.ability;
if (ability == this.GetAbility()) {
this.last_reset = GameRules.GetGameTime();
this.SetStackCount(0);
this.current_stacks = 0;
this.activity = "";
return;
}
if (ability.IsItem()) return;
this.UpdateStacks(event.unit);
}
/****************************************/
GetActivityTranslationModifiers(): string {
return this.activity!;
}
/****************************************/
OnTooltip(): number {
return this.cast_time_per_action!;
}
/****************************************/
UpdateStacks(unit: CDOTA_BaseNPC): void {
if (!unit || unit != this.GetParent()) return;
let creation_time = GameRules.GetGameTime();
this.current_stacks!++;
this.SetStackCount(math.min(this.max_stacks!, this.current_stacks!));
Timers.CreateTimer(this.action_window!, () => {
if (this.last_reset > creation_time) return;
this.current_stacks!--;
this.SetStackCount(math.min(this.max_stacks!, this.current_stacks!));
this.UpdateActivity();
});
this.UpdateActivity();
}
/****************************************/
UpdateActivity(): void {
let stacks = this.GetStackCount();
if (stacks % 2 != 0) stacks--;
this.activity = this.castpoint_activies[stacks];
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/neji/neji_innate_passive.ts
|
<filename>src/vscripts/abilities/heroes/neji/neji_innate_passive.ts<gh_stars>0
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class neji_innate_passive extends BaseAbility
{
OnUpgrade(): void {
//Should refresh modifier on eanch upgrade
this.GetCaster().FindModifierByName(this.GetIntrinsicModifierName())?.ForceRefresh()
}
GetIntrinsicModifierName(): string {
return "modifier_neji_innate_passive_intrinsic"
}
}
@registerModifier()
export class modifier_neji_innate_passive_intrinsic extends BaseModifier
{
damage_reduction_per_percent_of_mana: number = 0
IsHidden(): boolean {
return true
}
IsDebuff(): boolean {
return false
}
IsPermanent(): boolean {
return true
}
IsPurgable(): boolean {
return false
}
OnCreated(): void {
let ability = this.GetAbility()
if(ability){
this.damage_reduction_per_percent_of_mana = ability.GetSpecialValueFor("damage_reduction_per_percent_of_mana_base") + (ability.GetSpecialValueFor("damage_reduction_per_percent_of_mana_per_level_bonus") * (ability.GetLevel() - 1))
}
}
OnRefresh(): void {
let ability = this.GetAbility()
if(ability){
this.damage_reduction_per_percent_of_mana = ability.GetSpecialValueFor("damage_reduction_per_percent_of_mana_base") + (ability.GetSpecialValueFor("damage_reduction_per_percent_of_mana_per_level_bonus") * (ability.GetLevel() - 1))
}
}
DeclareFunctions(){
return [ModifierFunction.INCOMING_DAMAGE_PERCENTAGE]
}
GetModifierIncomingDamage_Percentage(){
let parent = this.GetParent()
return -1 * (this.damage_reduction_per_percent_of_mana * (parent.GetMana() / parent.GetMaxMana()) * 100)
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/shisui/shisui_afterimage_clone.ts
|
<filename>src/vscripts/abilities/heroes/shisui/shisui_afterimage_clone.ts
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface AfterimageModifier extends CDOTA_Buff
{
penalty_status?: boolean;
}
@registerAbility()
export class shisui_afterimage_clone extends BaseAbility {
clone?: CDOTA_BaseNPC;
/****************************************/
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/shisui/shisui_afterimage_clone_slash.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/shisui/game_sounds_shisui.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/shisui/game_sounds_vo_shisui.vsndevts", context);
}
/****************************************/
GetAOERadius(): number {
return this.GetSpecialValueFor("radius")
}
/****************************************/
GetCastAnimation(): GameActivity {
return GameActivity.DOTA_CHANNEL_ABILITY_2
}
GetPlaybackRateOverride(): number {
if (this.GetCaster().HasTalent("special_bonus_shisui_5")) return super.GetPlaybackRateOverride();
let attack_rate = this.GetLevelSpecialValueFor("attack_count", this.GetMaxLevel()) - this.GetSpecialValueFor("attack_count")
return (attack_rate == 0 ? 1 : attack_rate) * 0.45 + 1;
}
OnSpellStart(): void {
let caster = this.GetCaster();
let position = this.GetCursorPosition();
let radius = this.GetSpecialValueFor("radius");
let attack_count = this.GetSpecialValueFor("attack_count") + caster.FindTalentValue("special_bonus_shisui_5");
let enemies = FindUnitsInRadius(
caster.GetTeamNumber(),
position,
undefined,
radius,
this.GetAbilityTargetTeam(),
this.GetAbilityTargetType(),
UnitTargetFlags.NO_INVIS + UnitTargetFlags.NOT_ATTACK_IMMUNE + UnitTargetFlags.MAGIC_IMMUNE_ENEMIES,
FindOrder.ANY,
false
);
if (enemies.length == 0) return;
this.SetActivated(false);
let kv = {
outgoing_damage: -100,
incoming_damage: -100,
duration: 5
}
this.clone = CreateUnitByName("npc_dota_shisui_dummy", caster.GetAbsOrigin(), false, undefined, undefined, caster.GetTeamNumber());
this.clone.AddNewModifier(caster, this, "modifier_shisui_afterimage_clone_image", {duration: 5});
this.clone.AddNewModifier(caster, this, "modifier_kill", {duration: 5});
this.clone.SetForwardVector((position - this.clone.GetAbsOrigin() as Vector).Normalized());
this.clone.StartGesture(GameActivity.DOTA_CHANNEL_ABILITY_2);
//caster.StartGestureWithPlaybackRate(GameActivity.DOTA_CHANNEL_ABILITY_2, attack_rate);
caster.AddNewModifier(caster, this, "modifier_shisui_afterimage_clone", {duration: -1})
let heroes = FindUnitsInRadius(
caster.GetTeamNumber(),
position,
undefined,
radius,
this.GetAbilityTargetTeam(),
UnitTargetType.HERO,
UnitTargetFlags.NO_INVIS + UnitTargetFlags.NOT_ATTACK_IMMUNE + UnitTargetFlags.MAGIC_IMMUNE_ENEMIES,
FindOrder.ANY,
false
);
EmitSoundOnEntityForPlayer("VO_Hero_Shisui.AfterImage.Cast", caster, caster.GetPlayerOwnerID());
EmitSoundOn("Hero_Shisui.AfterImage.Cast", caster);
let enemy = heroes.length > 0 ? heroes[0] : enemies[0];
this.PerformJump(enemy, attack_count, {} as Record<EntityIndex, boolean>, position, this.GetSpecialValueFor("delay"));
}
/****************************************/
PerformJump(target: CDOTA_BaseNPC | undefined, attack_count: number, affected_enemies: Record<EntityIndex, boolean>, position: Vector, delay: number) {
let caster = this.GetCaster();
target = target as CDOTA_BaseNPC;
let pos = target.GetAbsOrigin() + target.GetForwardVector() * 150 as Vector;
pos = RotatePosition(target.GetAbsOrigin(), QAngle(0, RandomInt(0, 360), 0), pos);
caster.SetAbsOrigin(pos);
caster.SetForwardVector((target.GetAbsOrigin() - caster.GetAbsOrigin() as Vector).Normalized());
caster.StartGestureWithPlaybackRate(GameActivity.DOTA_ATTACK, 1.5); //test
//caster.StartGesture(GameActivity.DOTA_ATTACK_SPECIAL);
let modifier = caster.FindModifierByName("modifier_shisui_afterimage_clone") as AfterimageModifier;
modifier.penalty_status = affected_enemies[target.entindex()] ? true : false;
Timers.CreateTimer(delay, () => this.AttackTarget(target, attack_count, affected_enemies, position));
}
/****************************************/
AttackTarget(target: CDOTA_BaseNPC | undefined, attack_count: number, affected_enemies: Record<EntityIndex, boolean>, position: Vector): void {
let caster = this.GetCaster();
target = target as CDOTA_BaseNPC;
if (!target.IsInvisible() && !target.IsAttackImmune() && !target.IsInvulnerable()) {
caster.PerformAttack(target, false, true, true, false, false, false, false);
ParticleManager.ReleaseParticleIndex(
ParticleManager.CreateParticle("particles/units/heroes/shisui/shisui_afterimage_clone_slash.vpcf", ParticleAttachment.ABSORIGIN, target)
)
}
attack_count--;
affected_enemies[target.entindex()] = true;
if (attack_count > 0) this.FindNextTarget(position, attack_count, affected_enemies);
else this.StopAfterimage();
}
/****************************************/
FindNextTarget(position: Vector, attack_count: number, affected_enemies: Record<EntityIndex, boolean>) {
let caster = this.GetCaster();
let radius = this.GetSpecialValueFor("radius");
let target: CDOTA_BaseNPC | undefined = undefined;
let enemies = FindUnitsInRadius(
caster.GetTeamNumber(),
position,
undefined,
radius,
this.GetAbilityTargetTeam(),
this.GetAbilityTargetType(),
UnitTargetFlags.NO_INVIS + UnitTargetFlags.NOT_ATTACK_IMMUNE + UnitTargetFlags.MAGIC_IMMUNE_ENEMIES,
FindOrder.ANY,
false
);
let heroes = FindUnitsInRadius(
caster.GetTeamNumber(),
position,
undefined,
radius,
this.GetAbilityTargetTeam(),
UnitTargetType.HERO,
UnitTargetFlags.NO_INVIS + UnitTargetFlags.NOT_ATTACK_IMMUNE + UnitTargetFlags.MAGIC_IMMUNE_ENEMIES,
FindOrder.ANY,
false
);
if (enemies.length == 0) {
this.StopAfterimage();
return;
}
for (let [k, enemy] of Object.entries(heroes)) {
if (affected_enemies[enemy.entindex()]) continue;
target = enemy;
break;
}
if (!target) {
if (heroes.length > 0) target = heroes[RandomInt(0, heroes.length -1)];
else {
for (let [k, enemy] of Object.entries(enemies)) {
if (affected_enemies[enemy.entindex()]) continue;
target = enemy;
break;
}
}
}
target = target ? target : enemies[RandomInt(0, heroes.length -1)];
this.PerformJump(target, attack_count, affected_enemies, position, this.GetSpecialValueFor("delay"));
}
/****************************************/
StopAfterimage() {
let caster = this.GetCaster();
let origin = this.clone!.GetAbsOrigin();
let forward = this.clone!.GetForwardVector();
EmitSoundOnLocationWithCaster(origin, "General.Illusion.Destroy", caster);
let death_fx = ParticleManager.CreateParticle("particles/units/heroes/naruto/naruto_clone.vpcf", ParticleAttachment.CUSTOMORIGIN, undefined);
ParticleManager.SetParticleControl(death_fx, 0, origin + Vector(0, 0, 80) as Vector);
ParticleManager.ReleaseParticleIndex(death_fx);
UTIL_Remove(this.clone);
caster.SetAbsOrigin(origin);
caster.SetForwardVector(forward);
caster.RemoveGesture(GameActivity.DOTA_ATTACK);
//caster.FadeGesture(GameActivity.DOTA_CHANNEL_ABILITY_2);
caster.RemoveModifierByName("modifier_shisui_afterimage_clone");
this.SetActivated(true);
}
}
@registerModifier()
export class modifier_shisui_afterimage_clone extends BaseModifier
{
damage_penalty?: number;
penalty_status: boolean = false;
/****************************************/
OnCreated(params: object): void {
if (!IsServer()) return;
this.damage_penalty = -this.GetParent().GetAverageTrueAttackDamage(undefined) * this.GetAbility()!.GetSpecialValueFor("same_target_penalty") / 100;
}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.INVULNERABLE]: true,
[ModifierState.NO_UNIT_COLLISION]: true,
[ModifierState.UNSELECTABLE]: true,
[ModifierState.UNTARGETABLE]: true,
[ModifierState.NO_HEALTH_BAR]: true,
[ModifierState.DISARMED]: true,
};
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.PREATTACK_BONUS_DAMAGE
]}
/****************************************/
GetModifierPreAttack_BonusDamage(): number {
if (!IsServer()) return 0;
return this.penalty_status ? this.damage_penalty! : 0;
}
}
@registerModifier()
export class modifier_shisui_afterimage_clone_image extends BaseModifier
{
IsHidden(): boolean {return true}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.CANNOT_BE_MOTION_CONTROLLED]: true,
[ModifierState.INVULNERABLE]: true,
[ModifierState.DISARMED]: true,
[ModifierState.ROOTED]: true,
[ModifierState.NO_UNIT_COLLISION]: true,
[ModifierState.UNSELECTABLE]: true,
[ModifierState.UNTARGETABLE]: true,
[ModifierState.NO_HEALTH_BAR]: true,
};
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/kakashi/kakashi_kamui.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class kakashi_kamui extends BaseAbility
{
target?: CDOTA_BaseNPC_Hero;
/****************************************/
Precache(context: CScriptPrecacheContext): void{
//PrecacheResource("particle", "particles/units/heroes/kakashi/chidori.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/kakashi/game_sounds_kakashi.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/kakashi/game_sounds_vo_kakashi.vsndevts", context);
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let target = this.GetCursorTarget();
let channel_time = this.GetChannelTime();
if (target?.TriggerSpellAbsorb(this)) return;
this.target = target as CDOTA_BaseNPC_Hero;
target?.AddNewModifier(caster, this, "modifier_kakashi_kamui", {duration: channel_time});
caster.AddNewModifier(caster, this, "modifier_kakashi_kamui_channeling", {duration: channel_time});
EmitSoundOn("Hero_Kakashi.Kamui.Channel", caster);
EmitSoundOn("Hero_Kakashi.Kamui.Channel", target!);
}
/****************************************/
OnChannelThink(interval: number): void {
let caster = this.GetCaster();
if ((caster.GetAbsOrigin() - this.target!.GetAbsOrigin() as Vector).Length2D() > this.GetSpecialValueFor("focus_range"))
caster.InterruptChannel();
}
/****************************************/
OnChannelFinish(interrupted: boolean): void {
let caster = this.GetCaster();
this.target?.RemoveModifierByNameAndCaster("modifier_kakashi_kamui", caster);
caster.RemoveModifierByName("modifier_kakashi_kamui_channeling");
StopSoundOn("Hero_Kakashi.Kamui.Channel", caster);
if (interrupted) {
StopSoundOn("Hero_Kakashi.Kamui.Channel", this.target!);
return;
}
this.target?.AddNewModifier(caster, this, "modifier_kakashi_kamui_banish", {duration: this.GetSpecialValueFor("banish_duration")});
EmitSoundOn("Hero_Kakashi.Kamui.Banish", this.target!);
EmitSoundOn("Hero_Kakashi.Kamui.Fire", caster);
}
}
@registerModifier()
export class modifier_kakashi_kamui extends BaseModifier
{
initial_slow?: number;
max_slow?: number;
duration?: number;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: Object): void {
let ability = this.GetAbility()!;
this.initial_slow = -ability.GetSpecialValueFor("initial_slow");
this.max_slow = -ability.GetSpecialValueFor("max_slow");
this.duration = ability.GetChannelTime();
}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {[ModifierState.PROVIDES_VISION]: true};
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.MOVESPEED_BONUS_PERCENTAGE,
]}
/****************************************/
GetModifierMoveSpeedBonus_Percentage(): number {
return math.min(this.initial_slow!, this.max_slow! * ((this.duration! - this.GetRemainingTime()) / this.duration!));
}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/hero_void_spirit/void_spirit_disruption_refract.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN_FOLLOW;
}
}
@registerModifier()
export class modifier_kakashi_kamui_banish extends BaseModifier
{
break_duration?: number;
max_health_damage?: number;
/****************************************/
IsPurgable(): boolean {return false}
/****************************************/
OnCreated(params: object): void {
if (!IsServer()) return;
let ability = this.GetAbility();
let parent = this.GetParent();
this.break_duration = ability?.GetSpecialValueFor("break_duration");
this.max_health_damage = ability?.GetSpecialValueFor("max_health_damage");
parent.Purge(true, false, false, false, true);
parent.AddNoDraw();
let banish_fx = ParticleManager.CreateParticle("particles/units/heroes/hero_void_spirit/void_spirit_disruption_refract.vpcf", ParticleAttachment.WORLDORIGIN, undefined);
ParticleManager.SetParticleControl(banish_fx, 0, parent.GetAbsOrigin());
this.AddParticle(banish_fx, false, false, -1, false, false);
let overhead_fx = ParticleManager.CreateParticle("particles/customgames/capturepoints/cp_wind_captured.vpcf", ParticleAttachment.WORLDORIGIN, undefined);
ParticleManager.SetParticleControl(overhead_fx, 0, parent.GetAbsOrigin());
this.AddParticle(overhead_fx, false, false, -1, false, false);
}
OnDestroy(): void {
if (!IsServer()) return;
let parent = this.GetParent();
let caster = this.GetCaster();
let ability = this.GetAbility();
parent.RemoveNoDraw();
parent.AddNewModifier(caster, ability, "modifier_kakashi_kamui_break", {duration: this.break_duration! * (1 - parent.GetStatusResistance())});
ApplyDamage({
attacker: caster as CDOTA_BaseNPC,
victim: parent,
damage: this.max_health_damage! * parent.GetMaxHealth() / 100,
damage_type: ability?.GetAbilityDamageType() as DamageTypes,
damage_flags: DamageFlag.BYPASSES_INVULNERABILITY,
ability: ability
})
ParticleManager.ReleaseParticleIndex(
ParticleManager.CreateParticle("particles/units/heroes/hero_primal_beast/primal_beast_pulverize_hit_screenshake.vpcf", ParticleAttachment.ABSORIGIN, parent)
);
EmitSoundOn("Hero_Kakashi.Kamui.Damage", parent);
}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.OUT_OF_GAME]: true,
[ModifierState.NO_UNIT_COLLISION]: true,
[ModifierState.INVULNERABLE]: true,
[ModifierState.STUNNED]: true,
[ModifierState.SILENCED]: true,
};
}
}
@registerModifier()
export class modifier_kakashi_kamui_break extends BaseModifier
{
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.PASSIVES_DISABLED]: true,
[ModifierState.INVISIBLE]: false,
};
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.PROVIDES_FOW_POSITION,
]}
/****************************************/
GetModifierProvidesFOWVision(): 0 | 1 {
return 1;
}
/****************************************/
GetEffectName(): string {
return "particles/generic_gameplay/generic_break.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.OVERHEAD_FOLLOW;
}
/****************************************/
GetPriority(): ModifierPriority {
return ModifierPriority.SUPER_ULTRA;
}
}
// Hidden modifier to allow lightning release casting without interruption
@registerModifier()
export class modifier_kakashi_kamui_channeling extends BaseModifier
{
IsHidden(): boolean {return true}
IsPurgable(): boolean {return false}
}
|
jaden-young/NWR
|
src/vscripts/components/lul/malubulul.ts
|
<reponame>jaden-young/NWR<gh_stars>0
const steamIds = new Set([
"76561198094209497",
"76561197996145212",
"76561198074948631",
"76561198071444875",
"76561197982043049",
"76561199034723174",
"76561198000198627",
]);
export function malulubul(playerId: PlayerID) {
const steamId = PlayerResource.GetSteamID(playerId);
print("steamId: " + steamId);
if (!steamIds.has(tostring(steamId))) {
return;
}
const malulubuler = PlayerResource.GetPlayer(playerId);
EmitSoundOn("malulubul", malulubuler!.GetAssignedHero());
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/haku/haku_needles.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class haku_needles extends BaseAbility
{
Precache(context: CScriptPrecacheContext){
PrecacheResource("soundfile", "soundevents/game_sounds_heroes/game_sounds_crystalmaiden.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/haku/haku_deathneedle.vsndevts", context)
PrecacheResource("particle", "particles/units/heroes/haku/haku_needles", context)
PrecacheResource("particle", "particles/units/heroes/hero_legion_commander/legion_commander_odds.vpcf", context)
}
GetAOERadius(): number {
return this.GetSpecialValueFor("radius")
}
ProcsMagicStick(): boolean {
return true
}
OnSpellStart(): void {
if(!IsServer()){return}
let target_point = this.GetCursorPosition()
let duration = (this.GetSpecialValueFor("wave_interval") * this.GetSpecialValueFor("wave_count")) + this.GetSpecialValueFor("delay") + 0.1
let thinker = CreateModifierThinker(this.GetCaster(), this, "modifier_haku_needles_thinker", {duration: duration}, target_point, this.GetCaster().GetTeamNumber(), false)
this.GetCaster().EmitSound("haku_deathneedle")
//Creates flying vision area
this.CreateVisibilityNode(target_point, this.GetSpecialValueFor("radius"), duration)
}
}
@registerModifier()
export class modifier_haku_needles_thinker extends BaseModifier
{
wave_count: number = 0
delay: number = 0
damage: number = 0
vfx: any;
OnCreated(params: object): void {
if(!IsServer()){return}
let ability = this.GetAbility()
if(!ability){return}
let caster = ability.GetCaster()
if(!caster){return}
this.wave_count = ability.GetSpecialValueFor("wave_count")
this.damage = ability.GetSpecialValueFor("wave_damage") + caster.FindTalentValue("special_bonus_haku_4")
this.delay = ability.GetSpecialValueFor("delay")
// this.OnIntervalThink()
this.StartIntervalThink(this.delay)
}
OnIntervalThink(): void {
let caster = this.GetCaster()
if(!caster){return}
let ability = this.GetAbility()
if(!ability){return}
if(this.wave_count === 0){
this.StartIntervalThink(-1)
return
}
this.wave_count--
let particleName = "particles/units/heroes/hero_haku/haku_needles_base.vpcf"
let wave_interval = ability.GetSpecialValueFor("wave_interval")
let radius = ability.GetSpecialValueFor("radius")
this.vfx = ParticleManager.CreateParticle( particleName, ParticleAttachment.CUSTOMORIGIN, caster)
//CP1 - position of caster
//CP4 - X - radius, Y - thicknes, Z - speed
//CP5 - number of needles to emit (not sure how exactly it corelates), alpha values for some childs (maybe something else?)
ParticleManager.SetParticleControl(this.vfx, 0, this.GetParent().GetAbsOrigin())
ParticleManager.SetParticleControl(this.vfx, 1, caster.GetAbsOrigin())
ParticleManager.SetParticleControl(this.vfx, 4, Vector(radius,0,0))
ParticleManager.SetParticleControl(this.vfx, 5, Vector(radius,0,0))
let units = FindUnitsInRadius(caster.GetTeam(),
this.GetParent().GetAbsOrigin(),
undefined,
radius,
ability.GetAbilityTargetTeam(),
ability.GetAbilityTargetType(),
ability.GetAbilityTargetFlags(),
FindOrder.ANY,
false)
units.forEach((unit) => {
if(unit.IsBuilding()){return}
if(!caster){return}
if(!ability){return}
ApplyDamage({
victim: unit,
attacker: caster,
damage: this.damage,
damage_type: ability.GetAbilityDamageType(),
ability: ability
})
let root_duration = ability.GetSpecialValueFor("stun_duration")
unit.AddNewModifier(caster, ability,"modifier_haku_needles_victim_debuff",{duration: root_duration})
})
EmitSoundOnLocationWithCaster(this.GetParent().GetAbsOrigin(), "hero_Crystal.freezingField.explosion", caster)
this.StartIntervalThink(wave_interval)
}
OnDestroy(): void {
ParticleManager.DestroyParticle(this.vfx, false)
ParticleManager.ReleaseParticleIndex(this.vfx)
}
}
@registerModifier()
export class modifier_haku_needles_victim_debuff extends BaseModifier
{
IsPurgable(): boolean {
return true
}
IsPermanent(): boolean {
return false
}
IsDebuff(): boolean {
return true
}
IsHidden(): boolean {
return false
}
CheckState(){
return {[ModifierState.ROOTED]: true}
}
//TODO: VFX
}
|
jaden-young/NWR
|
src/vscripts/modifiers/modifier_custom_mechanics.ts
|
<filename>src/vscripts/modifiers/modifier_custom_mechanics.ts
import { BaseModifier, registerModifier } from "../lib/dota_ts_adapter";
import { ShortHeroName } from "../lib/util";
@registerModifier()
class modifier_custom_mechanics extends BaseModifier {
IsHidden(): boolean {
return false;
}
IsPurgable(): boolean {
return false;
}
RemoveOnDeath(): boolean {
return false;
}
OnCreated(params: object): void {
const short_hero_name = ShortHeroName(this.GetParent().GetUnitName());
CreateEmptyTalents(short_hero_name);
}
}
|
jaden-young/NWR
|
src/vscripts/lib/vector_targeting_interface.ts
|
<gh_stars>0
import { BaseAbility } from "./dota_ts_adapter";
export interface BaseVectorAbility extends BaseAbility {
GetVectorTargetRange():number;
GetVectorTargetStartRadius():number;
GetVectorTargetEndRadius():number;
GetVectorPosition():Vector;
GetVector2Position():Vector;
GetVectorDirection():Vector;
UpdateVectorValues():void;
OnVectorCastStart(vStartLocation: Vector, vDirection: Vector):void;
IsDualVectorDirection():boolean;
IgnoreVectorArrowWidth():boolean;
}
export class BaseVectorAbility {}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/zabuza/zabuza_kirigakure_no_jutsu.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface kv
{
shard_cast?: number;
}
@registerAbility()
export class zabuza_kirigakure_no_jutsu extends BaseAbility
{
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/zabuza/zabuza_mist_core.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/zabuza/zabuza_mist_talking.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/zabuza/zabuza_mist_loop.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/zabuza/zabuza_mist_cast.vsndevts", context);
}
/****************************************/
GetAOERadius(): number {
return this.GetSpecialValueFor("radius");
}
/****************************************/
OnAbilityPhaseStart(): boolean {
EmitSoundOn("zabuza_mist_cast", this.GetCaster());
return true
}
/****************************************/
OnSpellStart(): void {
this.CreateMist(false, this.GetCursorPosition());
}
/****************************************/
CreateMist(shard_cast: boolean, position: Vector): void {
let caster = this.GetCaster();
let duration = this.GetSpecialValueFor("duration")
CreateModifierThinker(caster, this, "modifier_zabuza_kirigakure_no_jutsu", {duration: duration, shard_cast: shard_cast}, position, caster.GetTeamNumber(), false);
EmitSoundOn("zabuza_mist_talking", caster);
}
}
@registerModifier()
export class modifier_zabuza_kirigakure_no_jutsu extends BaseModifier
{
radius: number = 0;
fade_delay?: number;
/****************************************/
IsPurgable(): boolean {return true}
IsAura(): boolean {return true}
GetAuraRadius(): number {return this.radius}
GetAuraSearchTeam(): UnitTargetTeam {return UnitTargetTeam.FRIENDLY}
GetAuraSearchType(): UnitTargetType {return UnitTargetType.HERO}
GetModifierAura(): string {return "modifier_zabuza_kirigakure_no_jutsu_aura"}
/****************************************/
OnCreated(params: kv): void {
if (!IsServer()) return;
let parent = this.GetParent();
let ability = this.GetAbility();
this.radius = params.shard_cast == 1 ? ability!.GetSpecialValueFor("shard_radius") : ability!.GetSpecialValueFor("radius");
this.fade_delay = ability!.GetSpecialValueFor("fade_delay") + this.GetCaster()!.FindTalentValue("special_bonus_zabuza_4");
let mist_fx = ParticleManager.CreateParticle("particles/units/heroes/zabuza/zabuza_mist_core.vpcf", ParticleAttachment.ABSORIGIN, parent);
ParticleManager.SetParticleControl(mist_fx, 1, Vector(this.radius+100, 0, 150));
this.AddParticle(mist_fx, false, false, -1, false, false);
EmitSoundOn("zabuza_mist_loop", parent);
this.StartIntervalThink(0.1);
this.OnIntervalThink();
}
OnDestroy(): void {
if (!IsServer()) return;
StopSoundOn("zabuza_mist_loop", this.GetParent());
}
/****************************************/
OnIntervalThink(): void {
let parent = this.GetParent();
let allies = FindUnitsInRadius(parent.GetTeamNumber(),
parent.GetAbsOrigin(),
undefined, this.radius,
UnitTargetTeam.FRIENDLY,
UnitTargetType.HERO + UnitTargetType.BASIC,
UnitTargetFlags.NONE,
FindOrder.ANY,
false
);
allies.forEach(ally => {
if (ally.IsHero() && !ally.HasModifier("modifier_zabuza_kirigakure_no_jutsu_fade") && !ally.HasModifier("modifier_zabuza_kirigakure_no_jutsu_invis"))
ally.AddNewModifier(this.GetCaster(), this.GetAbility(), "modifier_zabuza_kirigakure_no_jutsu_fade", {duration: this.fade_delay});
if (ally.GetPlayerOwnerID() == parent.GetPlayerOwnerID())
ally.AddNewModifier(this.GetCaster(), this.GetAbility(), "modifier_zabuza_kirigakure_no_jutsu_speed", {duration: -1});
});
}
}
@registerModifier()
export class modifier_zabuza_kirigakure_no_jutsu_speed extends BaseModifier
{
move_speed?: number;
damage?: number;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: object): void {
this.move_speed = this.GetAbility()?.GetSpecialValueFor("bonus_movespeed");
this.damage = this.GetAbility()!.GetSpecialValueFor("special_bonus_5_damage") + this.GetCaster()!.FindTalentValue("special_bonus_zabuza_5");
if (IsServer()) this.StartIntervalThink(0.1);
}
/****************************************/
OnIntervalThink(): void {
if (!this.GetParent().HasModifier("modifier_zabuza_kirigakure_no_jutsu_aura")) this.Destroy();
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.MOVESPEED_BONUS_PERCENTAGE,
ModifierFunction.PREATTACK_BONUS_DAMAGE
]}
/****************************************/
GetModifierMoveSpeedBonus_Percentage(): number {
return this.move_speed!;
}
/****************************************/
GetModifierPreAttack_BonusDamage(): number {
return this.damage!;
}
}
@registerModifier()
export class modifier_zabuza_kirigakure_no_jutsu_fade extends BaseModifier
{
duration?: number;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: object): void {
if (IsServer()) this.StartIntervalThink(0.1);
}
/****************************************/
OnDestroy(): void {
if (!IsServer()) return;
if (this.GetParent().HasModifier("modifier_zabuza_kirigakure_no_jutsu_aura")) {
this.GetParent().AddNewModifier(this.GetCaster(), this.GetAbility(), "modifier_zabuza_kirigakure_no_jutsu_invis", {duration: -1});
}
}
/****************************************/
OnIntervalThink(): void {
if (!this.GetParent().HasModifier("modifier_zabuza_kirigakure_no_jutsu_aura")) this.Destroy();
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.ON_ATTACK_LANDED,
ModifierFunction.ON_ABILITY_EXECUTED
]}
/****************************************/
OnAttackLanded(event: ModifierAttackEvent): void {
if (!IsServer()) return;
if (event.attacker != this.GetParent()) return;
this.ForceRefresh();
}
/****************************************/
OnAbilityExecuted(event: ModifierAbilityEvent): void {
if (!IsServer()) return;
if (event.unit != this.GetParent()) return;
this.ForceRefresh();
}
}
@registerModifier()
export class modifier_zabuza_kirigakure_no_jutsu_invis extends BaseModifier
{
fade_delay?: number;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: object): void {
this.fade_delay = this.GetAbility()!.GetSpecialValueFor("fade_delay") + this.GetCaster()!.FindTalentValue("special_bonus_zabuza_4");
if (IsServer()) this.StartIntervalThink(0.1);
}
/****************************************/
OnDestroy(): void {
if (!IsServer()) return;
if (this.GetParent().HasModifier("modifier_zabuza_kirigakure_no_jutsu_aura")){
this.GetParent().AddNewModifier(this.GetCaster(), this.GetAbility(), "modifier_zabuza_kirigakure_no_jutsu_fade", {duration: this.fade_delay});
}
}
/****************************************/
OnIntervalThink(): void {
if (!this.GetParent().HasModifier("modifier_zabuza_kirigakure_no_jutsu_aura")) this.Destroy();
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.INVISIBILITY_LEVEL,
ModifierFunction.ON_ATTACK_LANDED,
ModifierFunction.ON_ABILITY_EXECUTED
]}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.INVISIBLE]: true,
[ModifierState.NO_UNIT_COLLISION]: true
};
}
/****************************************/
GetModifierInvisibilityLevel(): number {
return 1
}
/****************************************/
OnAttackLanded(event: ModifierAttackEvent): void {
if (!IsServer()) return;
if (event.attacker != this.GetParent()) return;
this.Destroy();
}
/****************************************/
OnAbilityExecuted(event: ModifierAbilityEvent): void {
if (!IsServer()) return;
if (event.unit != this.GetParent()) return;
this.Destroy();
}
}
@registerModifier()
export class modifier_zabuza_kirigakure_no_jutsu_aura extends BaseModifier
{
IsPurgable(): boolean {return false}
IsHidden(): boolean {return true}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/sai/sai_kamis_strength_remote.ts
|
<gh_stars>0
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface SuperGodDrawingAbility
{
agyo?: CDOTA_BaseNPC;
ungyo?: CDOTA_BaseNPC;
}
@registerAbility()
export class sai_kamis_strength_remote extends BaseAbility {
Precache(context: CScriptPrecacheContext): void{
//PrecacheResource("particle", "", context);
PrecacheResource("soundfile", "soundevents/heroes/sai/game_sounds_sai.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/sai/game_sounds_vo_sai.vsndevts", context);
}
/****************************************/
Spawn(): void {
if (!IsServer()) return;
this.SetLevel(1);
this.SetActivated(false);
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let drawing_ability = caster.FindAbilityByName("sai_super_god_drawing") as SuperGodDrawingAbility;
if (!drawing_ability) return;
let cd1 = this.CastKamisStrength(drawing_ability.agyo);
let cd2 = this.CastKamisStrength(drawing_ability.ungyo);
if (cd1 != -1 || cd2 != -1) {
this.EndCooldown()
this.StartCooldown(cd1 > cd2 ? cd2 : cd1);
}
}
CastKamisStrength(unit: CDOTA_BaseNPC | undefined): number {
if (!unit || unit.IsNull() || !unit.IsAlive()) return -1;
let ability = unit.FindAbilityByName("sai_kamis_strength");
if (ability && !unit.IsSilenced()) {
if (ability.IsCooldownReady()) {
ability.OnSpellStart();
ability.UseResources(true, false, true);
return ability.GetCooldownTimeRemaining();
} else {
return ability.GetCooldownTimeRemaining();
}
}
return -1
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/sakura/sakura_cherry_blossom_burst.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface SakuraInnate extends CDOTA_Buff
{
CanProc(): boolean;
ProcEnhancedStrength(target: CDOTA_BaseNPC, reset: boolean): void;
}
interface extra
{
proc_passive?: number;
}
@registerAbility()
export class sakura_cherry_blossom_burst extends BaseAbility {
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/sakura/sakura_cherry_blossom_burst.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/sakura/game_sounds_sakura.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/sakura/game_sounds_vo_sakura.vsndevts", context);
}
/****************************************/
OnAbilityPhaseStart(): boolean {
if (!IsServer()) return true;
let caster = this.GetCaster();
let sound = "Hero_Sakura.CherryBlossomBurst.Talk";
let innate = caster.FindAbilityByName("sakura_innate_passive");
if (innate) {
let modifier = caster.FindModifierByName(innate.GetIntrinsicModifierName()) as SakuraInnate;
let proc = modifier ? modifier!.CanProc() : false;
sound = proc ? "Hero_Sakura.CherryBlossomBurst.TalkCharged" : sound;
}
EmitSoundOn(sound, this.GetCaster());
return true
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let position = this.GetCursorPosition();
let radius = this.GetSpecialValueFor("radius");
let speed = this.GetSpecialValueFor("speed");
let innate = caster.FindAbilityByName("sakura_innate_passive");
let modifier = undefined;
let proc = false;
if (innate) modifier = caster.FindModifierByName(innate.GetIntrinsicModifierName()) as SakuraInnate;
proc = modifier ? modifier!.CanProc() : false;
let particle_fx = proc ? "particles/units/heroes/sakura/sakura_cherry_blossom_burst_charged.vpcf" : "particles/units/heroes/sakura/sakura_cherry_blossom_burst.vpcf"
let direction = position - caster.GetAbsOrigin() as Vector;
direction.z = 0;
direction = direction.Normalized();
ProjectileManager.CreateLinearProjectile({
Ability: this,
EffectName: particle_fx,
vSpawnOrigin: caster.GetAttachmentOrigin(caster.ScriptLookupAttachment("attach_right_hand")) as Vector,
fDistance: this.GetEffectiveCastRange(position, caster),
Source: caster,
fStartRadius: radius,
fEndRadius: radius,
iUnitTargetTeam: UnitTargetTeam.ENEMY,
iUnitTargetType: UnitTargetType.BASIC + UnitTargetType.HERO,
iUnitTargetFlags: UnitTargetFlags.NONE,
vVelocity: direction * speed as Vector,
ExtraData: {
proc_passive: proc
}
});
if (proc) {
modifier?.SetStackCount(0);
} else {
modifier?.IncrementStackCount();
}
EmitSoundOn("Hero_Sakura.CherryBlossomBurst.Cast", caster);
}
/****************************************/
OnProjectileHit_ExtraData(target: CDOTA_BaseNPC | undefined, location: Vector, extraData: extra): boolean | void {
if (!target || !this || this.IsNull()) return;
let caster = this.GetCaster();
let innate_ability = caster.FindAbilityByName("sakura_innate_passive")!;
let damage_table : ApplyDamageOptions = {
attacker: caster,
victim: target,
damage: this.GetSpecialValueFor("damage"),
damage_type: this.GetAbilityDamageType(),
ability: this
}
ApplyDamage(damage_table);
target.AddNewModifier(caster, this, "modifier_sakura_cherry_blossom_burst", {duration: this.GetSpecialValueFor("slow_duration") * (1 - target.GetStatusResistance())});
if (extraData.proc_passive == 1 && innate_ability) {
let modifier = caster.FindModifierByName(innate_ability.GetIntrinsicModifierName()) as SakuraInnate;
modifier.ProcEnhancedStrength(target, false);
}
ParticleManager.ReleaseParticleIndex(
ParticleManager.CreateParticle("particles/econ/items/dazzle/dazzle_ti9/dazzle_shadow_wave_ti9_impact_damage_bits.vpcf", ParticleAttachment.ABSORIGIN, target)
);
//EmitSoundOn("", target);
}
}
@registerModifier()
export class modifier_sakura_cherry_blossom_burst extends BaseModifier
{
move_slow?: number;
/****************************************/
OnCreated(params: object): void {
this.move_slow = -this.GetAbility()!.GetSpecialValueFor("move_slow");
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.MOVESPEED_BONUS_PERCENTAGE,
]}
/****************************************/
GetModifierMoveSpeedBonus_Percentage(): number {
return this.move_slow!;
}
/****************************************/
GetEffectName(): string {
return "particles/items3_fx/witch_blade_debuff_arcs.vpcf"
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN_FOLLOW
}
/****************************************/
}
|
jaden-young/NWR
|
src/vscripts/lib/util.ts
|
<reponame>jaden-young/NWR
import "./utilities";
export function ShortHeroName(fullUnitName: string): string {
return fullUnitName.replace("npc_dota_hero_", "")
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/kakashi/kakashi_lightning_blade.ts
|
<reponame>jaden-young/NWR
import { BaseAbility, BaseModifier, BaseModifierMotionHorizontal, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface kv {
target: EntityIndex;
}
interface AbilityWithPhaseStartFX
{
lightning_blade_fx?: ParticleID;
}
@registerAbility()
export class kakashi_lightning_blade extends BaseAbility implements AbilityWithPhaseStartFX
{
lightning_blade_fx?: ParticleID;
active_target?: CDOTA_BaseNPC;
/****************************************/
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/kakashi/chidori.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/kakashi/game_sounds_kakashi.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/kakashi/game_sounds_vo_kakashi.vsndevts", context);
}
/****************************************/
GetCastPoint(): number {
return super.GetCastPoint() - this.GetCaster().FindTalentValue("special_bonus_kakashi_2");
}
/****************************************/
OnAbilityPhaseStart(): boolean {
let caster = this.GetCaster();
this.active_target = this.GetCursorTarget();
this.lightning_blade_fx = ParticleManager.CreateParticle("particles/units/heroes/kakashi/chidori.vpcf", ParticleAttachment.ABSORIGIN_FOLLOW, caster);
ParticleManager.SetParticleControlEnt(this.lightning_blade_fx, 0, caster, ParticleAttachment.POINT_FOLLOW, "attach_right_hand", caster.GetAbsOrigin(), true);
EmitSoundOn("VO_Hero_Kakashi.LightningBlade.Precast", caster)
EmitSoundOn("Hero_Kakashi.LightningBlade.Precast", caster)
this.active_target!.AddNewModifier(caster, this, "modifier_kakashi_lightning_blade_target", {duration: -1})
return true;
}
/****************************************/
OnAbilityPhaseInterrupted(): void {
let caster = this.GetCaster();
ParticleManager.DestroyParticle(this.lightning_blade_fx!, true);
ParticleManager.ReleaseParticleIndex(this.lightning_blade_fx!);
StopSoundOn("VO_Hero_Kakashi.LightningBlade.Precast", caster)
StopSoundOn("Hero_Kakashi.LightningBlade.Precast", caster)
this.active_target?.RemoveModifierByName("modifier_kakashi_lightning_blade_target");
this.active_target = undefined;
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let target = this.GetCursorTarget();
if (target?.TriggerSpellAbsorb(this)) return;
caster.AddNewModifier(caster, this, "modifier_kakashi_lightning_blade", {duration: -1, target: target?.entindex()})
}
}
@registerModifier()
export class modifier_kakashi_lightning_blade extends BaseModifierMotionHorizontal
{
target?: CDOTA_BaseNPC;
charge_speed?: number;
damage?: number;
stun_duration?: number;
max_distance?: number;
activity_fired = false;
cancelling_orders = [
UnitOrder.STOP,
UnitOrder.HOLD_POSITION,
UnitOrder.MOVE_TO_POSITION,
UnitOrder.MOVE_TO_DIRECTION,
UnitOrder.MOVE_TO_TARGET,
UnitOrder.ATTACK_MOVE,
UnitOrder.CAST_POSITION,
UnitOrder.CAST_TARGET,
UnitOrder.CAST_TARGET_TREE,
UnitOrder.VECTOR_TARGET_POSITION,
UnitOrder.PATROL
]
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: kv): void {
let ability = this.GetAbility()!;
this.charge_speed = ability.GetSpecialValueFor("charge_speed");
this.damage = ability.GetSpecialValueFor("damage") + this.GetParent().FindTalentValue("special_bonus_kakashi_1");
this.stun_duration = ability.GetSpecialValueFor("stun_duration");
this.max_distance = ability.GetSpecialValueFor("max_distance");
if (!IsServer()) return;
EmitSoundOn("Hero_Kakashi.LightningBlade.Loop", this.GetParent());
this.target = EntIndexToHScript(params.target) as CDOTA_BaseNPC;
if (!this.ApplyHorizontalMotionController()) {
this.Destroy()
return;
}
}
/****************************************/
OnDestroy(): void {
if (!IsServer()) return;
let parent = this.GetParent();
let ability = this.GetAbility() as AbilityWithPhaseStartFX;
parent.RemoveHorizontalMotionController(this);
if (this.target && !this.target.IsNull() && this.target.HasModifier("modifier_kakashi_lightning_blade_target")) {
this.target.RemoveModifierByName("modifier_kakashi_lightning_blade_target");
}
ParticleManager.DestroyParticle(ability!.lightning_blade_fx!, true);
ParticleManager.ReleaseParticleIndex(ability!.lightning_blade_fx!);
Timers.CreateTimer(FrameTime(), () => {StopSoundOn("Hero_Kakashi.LightningBlade.Loop", parent)})
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.ON_ORDER,
ModifierFunction.OVERRIDE_ANIMATION,
]}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.NO_UNIT_COLLISION]: true,
[ModifierState.FLYING_FOR_PATHING_PURPOSES_ONLY]: true,
};
}
/****************************************/
UpdateHorizontalMotion(parent: CDOTA_BaseNPC, dt: number): void {
let direction = (this.target!.GetAbsOrigin() - parent.GetAbsOrigin() as Vector).Normalized();
this.CheckConditions();
if (this.CheckDistance()) return;
parent.FaceTowards(this.target!.GetAbsOrigin());
parent.SetAbsOrigin(parent.GetAbsOrigin() + this.charge_speed! * direction * dt as Vector);
}
/****************************************/
OnHorizontalMotionInterrupted(): void {
this.Destroy();
}
/****************************************/
OnOrder(params: ModifierAbilityEvent) {
if (!IsServer()) return;
let unit = params.unit;
let order = params.order_type;
if (!unit || unit != this.GetParent()) return;
if (this.cancelling_orders.includes(order)) this.Destroy();
if (order == UnitOrder.ATTACK_TARGET && params.target != this.target)
this.Destroy();
}
/****************************************/
GetOverrideAnimation(): GameActivity{
return GameActivity.DOTA_CHANNEL_ABILITY_5
}
/****************************************/
CheckConditions(): void {
let parent = this.GetParent();
if (parent.IsStunned() || parent.IsHexed() || parent.IsRooted() || this.target?.IsNull() || !this.target?.IsAlive()) this.Destroy();
}
/****************************************/
CheckDistance(): boolean {
let parent = this.GetParent();
let distance = (parent.GetAbsOrigin() - this.target!.GetAbsOrigin() as Vector).Length2D()
if (distance <= 350 && !this.activity_fired) {
this.activity_fired = true;
parent.StartGesture(GameActivity.DOTA_CAST_ABILITY_7);
}
if (distance <= 128) {
let ability = this.GetAbility();
ApplyDamage({
attacker: parent,
victim: this.target!,
damage: this.damage!,
damage_type: this.GetAbility()!.GetAbilityDamageType(),
ability: this.GetAbility(),
})
this.target?.AddNewModifier(parent, ability, "modifier_stunned", {duration: this.stun_duration! * (1 - this.target.GetStatusResistance())})
EmitSoundOn("Hero_Kakashi.LightningBlade.Impact", this.target!)
EmitSoundOn("VO_Hero_Kakashi.LightningBlade.Hit", parent)
let impact_fx = ParticleManager.CreateParticle("particles/units/heroes/hero_zuus/zuus_static_field.vpcf", ParticleAttachment.ABSORIGIN_FOLLOW, this.target);
ParticleManager.ReleaseParticleIndex(impact_fx);
this.Destroy()
return true;
} else if (distance > this.max_distance!) {
this.Destroy();
return true;
}
return false;
}
}
@registerModifier()
export class modifier_kakashi_lightning_blade_target extends BaseModifier
{
IsHidden(): boolean {return true}
IsPurgable(): boolean {return false}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.PROVIDES_VISION]: true,
};
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/guy/guy_hirudora.ts
|
<gh_stars>0
import { BaseAbility, registerAbility} from "../../../lib/dota_ts_adapter"
@registerAbility()
export class guy_hirudora extends BaseAbility
{
Precache(context: CScriptPrecacheContext): void{
//PrecacheResource("particle", "", context);
PrecacheResource("soundfile", "soundevents/heroes/guy/game_sounds_guy.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/guy/game_sounds_vo_guy.vsndevts", context);
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let position = this.GetCursorPosition();
let distance = this.GetCastRange(position, undefined);
let radius = this.GetSpecialValueFor("radius");
let direction = position - caster.GetAbsOrigin() as Vector;
direction.z = 0;
direction = direction.Normalized();
let spawn_pos = caster.GetAttachmentOrigin(caster.ScriptLookupAttachment("attach_hitloc")) + direction * 75 as Vector;
ProjectileManager.CreateLinearProjectile({
Ability: this,
EffectName: "particles/units/heroes/hero_vengeful/vengeful_wave_of_terror.vpcf",
vSpawnOrigin: spawn_pos,
fDistance: distance,
fStartRadius: radius,
fEndRadius: radius,
Source: caster,
iUnitTargetTeam: this.GetAbilityTargetTeam(),
iUnitTargetType: this.GetAbilityTargetType(),
iUnitTargetFlags: this.GetAbilityTargetFlags(),
vVelocity: direction * this.GetSpecialValueFor("speed") as Vector
});
ApplyDamage({
attacker: caster,
victim: caster,
damage: caster.GetHealth() * this.GetSpecialValueFor("hp_cost") / 100,
damage_type: DamageTypes.PURE,
damage_flags: DamageFlag.NON_LETHAL + DamageFlag.NO_SPELL_AMPLIFICATION + DamageFlag.NO_SPELL_LIFESTEAL + DamageFlag.REFLECTION,
ability: this
})
EmitSoundOn("Hero_Guy.Hirudora.Cast", caster);
}
/****************************************/
OnProjectileHit(target: CDOTA_BaseNPC | undefined, location: Vector): boolean | void {
if (!target) return true;
let caster = this.GetCaster();
ApplyDamage({
attacker: caster,
victim: target,
damage: caster.GetAverageTrueAttackDamage(undefined) * this.GetSpecialValueFor("attack_damage") / 100,
damage_type: this.GetAbilityDamageType(),
ability: this
})
let hit_fx = ParticleManager.CreateParticle("particles/units/heroes/hero_vengeful/vengeful_wave_of_terror_recipient.vpcf", ParticleAttachment.ABSORIGIN, target);
ParticleManager.DestroyParticle(hit_fx, false);
ParticleManager.ReleaseParticleIndex(hit_fx);
EmitSoundOn("Hero_Guy.Hirudora.Impact", target);
return false;
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/kisame/kisame_water_shark_bullet.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class kisame_water_shark_bullet extends BaseAbility
{
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/kisame/kisame_water_shark_bullet_explosion.vpcf", context);
PrecacheResource("particle", "particles/units/heroes/kisame/shark.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/kisame/game_sounds_kisame.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/kisame/game_sounds_vo_kisame.vsndevts", context);
}
/****************************************/
OnAbilityPhaseStart(): boolean {
EmitSoundOn("Hero_Kisame.WaterSharkBullet.Talk", this.GetCaster());
return true
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let position = this.GetCursorPosition();
let distance = this.GetCastRange(position, undefined);
let radius = this.GetSpecialValueFor("shark_radius");
let direction = position - caster.GetAbsOrigin() as Vector;
direction.z = 0;
direction = direction.Normalized();
let spawn_pos = caster.GetAttachmentOrigin(caster.ScriptLookupAttachment("attach_hitloc")) + direction * 75 as Vector;
ProjectileManager.CreateLinearProjectile({
Ability: this,
EffectName: "particles/units/heroes/kisame/shark.vpcf",
vSpawnOrigin: spawn_pos,
fDistance: distance,
fStartRadius: radius,
fEndRadius: radius,
Source: caster,
iUnitTargetTeam: this.GetAbilityTargetTeam(),
iUnitTargetType: this.GetAbilityTargetType(),
iUnitTargetFlags: this.GetAbilityTargetFlags(),
vVelocity: direction * this.GetSpecialValueFor("shark_speed") as Vector
});
EmitSoundOn("Hero_Kisame.WaterSharkBullet.Cast", caster);
}
/****************************************/
OnProjectileHit(target: CDOTA_BaseNPC | undefined, location: Vector): boolean | void {
if (!target) return true;
let caster = this.GetCaster();
let duration = this.GetSpecialValueFor("duration");
let radius = this.GetSpecialValueFor("explosion_radius");
let enemies = FindUnitsInRadius(
caster.GetTeamNumber(),
location,
undefined,
radius,
this.GetAbilityTargetTeam(),
this.GetAbilityTargetType(),
this.GetAbilityTargetFlags(),
FindOrder.ANY,
false
)
let damage_table: ApplyDamageOptions = {
attacker: caster,
victim: caster,
damage: this.GetSpecialValueFor("damage"),
damage_type: this.GetAbilityDamageType(),
ability: this
}
enemies.forEach(enemy => {
damage_table.victim = enemy;
ApplyDamage(damage_table);
enemy.AddNewModifier(caster, this, "modifier_kisame_water_shark_bullet", {duration: duration * (1 - enemy.GetStatusResistance())});
});
let explosion_fx = ParticleManager.CreateParticle("particles/units/heroes/kisame/kisame_water_shark_bullet_explosion.vpcf", ParticleAttachment.CUSTOMORIGIN, undefined);
ParticleManager.SetParticleControl(explosion_fx, 0, location);
ParticleManager.SetParticleControl(explosion_fx, 1, Vector(radius, 0, 0));
ParticleManager.SetParticleControl(explosion_fx, 3, Vector(radius, 0, 0));
ParticleManager.ReleaseParticleIndex(explosion_fx);
EmitSoundOnLocationWithCaster(location, "Hero_Kisame.WaterSharkBullet.Explosion", caster);
return true;
}
}
@registerModifier()
export class modifier_kisame_water_shark_bullet extends BaseModifier
{
move_slow?: number;
armor_reduction?: number;
/****************************************/
OnCreated(params: object): void {
let ability = this.GetAbility();
this.move_slow = -ability!.GetSpecialValueFor("move_slow");
this.armor_reduction = -ability!.GetSpecialValueFor("armor_reduction");
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.MOVESPEED_BONUS_PERCENTAGE,
ModifierFunction.PHYSICAL_ARMOR_BONUS
]}
/****************************************/
GetModifierMoveSpeedBonus_Percentage(): number {
return this.move_slow!
}
/****************************************/
GetModifierPhysicalArmorBonus(): number {
return this.armor_reduction!;
}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/hero_siren/naga_siren_riptide_debuff.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN_FOLLOW;
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/yondaime/yondaime_yellow_flash.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class yondaime_yellow_flash extends BaseAbility {
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/yondaime/yondaime_yellow_flash.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/yondaime/game_sounds_yondaime.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/yondaime/game_sounds_vo_yondaime.vsndevts", context);
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
caster.AddNewModifier(caster, this, "modifier_yondaime_yellow_flash", {duration: this.GetSpecialValueFor("duration")});
EmitSoundOn("Hero_yondaime.YellowFlash.Cast", caster);
}
}
@registerModifier()
export class modifier_yondaime_yellow_flash extends BaseModifier
{
move_speed?: number;
evasion?: number;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: Object): void {
let ability = this.GetAbility()!;
this.move_speed = ability.GetSpecialValueFor("move_speed");
this.evasion = ability.GetSpecialValueFor("evasion");
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.MOVESPEED_BONUS_PERCENTAGE,
ModifierFunction.EVASION_CONSTANT,
ModifierFunction.IGNORE_MOVESPEED_LIMIT
]}
/****************************************/
GetModifierMoveSpeedBonus_Percentage(): number {
return this.move_speed!;
}
/****************************************/
GetModifierEvasion_Constant(): number {
return this.evasion!;
}
/****************************************/
GetModifierIgnoreMovespeedLimit(): 1 | 0 {
return 1;
}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/yondaime/yondaime_yellow_flash.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN;
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/sai/sai_rat_reconnaissance.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface SaiInnate extends CDOTABaseAbility
{
ApplyDebuff(target: CDOTA_BaseNPC): void;
}
interface extra
{
rat_eid?: EntityIndex;
enemy_eid?: EntityIndex;
}
interface rat extends CDOTA_BaseNPC
{
emitted_sound?: boolean
}
@registerAbility()
export class sai_rat_reconnaissance extends BaseAbility
{
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/sai/sai_rat_reconnaissance_cast.vpcf", context);
PrecacheResource("particle", "particles/units/heroes/sai/sai_rat_reconnaissance_impact.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/sai/game_sounds_sai.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/sai/sai_rats_talking.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/sai/game_sounds_vo_sai.vsndevts", context);
}
/****************************************/
OnAbilityPhaseStart(): boolean {
EmitSoundOn("Hero_Sai.RatReconnaissance.PreCast", this.GetCaster());
EmitSoundOn("sai_rats_talking", this.GetCaster());
return true
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let origin = caster.GetAbsOrigin();
let target_count = this.GetSpecialValueFor("max_targets") + caster.FindTalentValue("special_bonus_sai_3");
let spawn_pos = origin + caster.GetForwardVector() * 40 as Vector
let rat_projectile: CreateTrackingProjectileOptions = {
Ability: this,
EffectName: "",
Target: undefined,
bDodgeable: false,
bDrawsOnMinimap: false,
bProvidesVision: true,
iMoveSpeed: this.GetSpecialValueFor("speed"),
iVisionRadius: 25,
iVisionTeamNumber: caster.GetTeamNumber(),
vSourceLoc: spawn_pos,
ExtraData: {
rat_eid: -1,
enemy_eid: -1
}
}
let enemies = FindUnitsInRadius(
caster.GetTeamNumber(),
origin,
undefined,
this.GetEffectiveCastRange(origin, caster),
UnitTargetTeam.ENEMY,
UnitTargetType.HERO,
UnitTargetFlags.NO_INVIS,
FindOrder.CLOSEST,
false
)
let cast_fx = ParticleManager.CreateParticle("particles/units/heroes/sai/sai_rat_reconnaissance_cast.vpcf", ParticleAttachment.CUSTOMORIGIN, undefined);
ParticleManager.SetParticleControl(cast_fx, 0, origin + caster.GetForwardVector() * 75 as Vector);
ParticleManager.SetParticleControlForward(cast_fx, 0, caster.GetForwardVector());
ParticleManager.ReleaseParticleIndex(cast_fx);
EmitSoundOn("Hero_Sai.RatReconnaissance.Cast", caster);
for (let [k, enemy] of Object.entries(enemies)) {
CreateUnitByNameAsync("npc_dota_sai_rat", spawn_pos, false, undefined, undefined, caster.GetTeamNumber(), (unit: rat) => {
unit.AddNewModifier(caster, this, "modifier_sai_super_beast_drawing_rat", {duration: -1});
unit.SetForwardVector(-(enemy.GetAbsOrigin() - caster.GetAbsOrigin() as Vector).Normalized() as Vector);
unit.StartGesture(GameActivity.DOTA_RUN);
unit.emitted_sound = false;
rat_projectile.Target = enemy;
(rat_projectile.ExtraData! as extra).rat_eid = unit.entindex();
(rat_projectile.ExtraData! as extra).enemy_eid = enemy.entindex();
ProjectileManager.CreateTrackingProjectile(rat_projectile);
target_count--;
});
if (target_count <= 0) break;
}
}
/****************************************/
OnProjectileThink_ExtraData(location: Vector, extraData: extra): void {
let rat = EntIndexToHScript(extraData.rat_eid!) as rat;
rat?.SetAbsOrigin(GetGroundPosition(location, rat));
if (!rat.emitted_sound) {
rat.emitted_sound = true;
EmitSoundOn("Hero_Sai.RatReconnaissance.Rat", rat);
}
let enemy = EntIndexToHScript(extraData.enemy_eid!) as CDOTA_BaseNPC;
if (enemy && !enemy.IsNull()) {
rat.SetForwardVector(-(enemy.GetAbsOrigin() - rat.GetAbsOrigin() as Vector).Normalized() as Vector);
}
}
/****************************************/
OnProjectileHit_ExtraData(target: CDOTA_BaseNPC | undefined, location: Vector, extraData: extra): boolean | void {
if (!target) {
this.KillRat(extraData.rat_eid!);
return true;
}
let caster = this.GetCaster();
let innate = caster.FindAbilityByName("sai_innate_passive") as SaiInnate;
let vision_duration = this.GetSpecialValueFor("vision_duration") + caster.FindTalentValue("special_bonus_sai_1");
this.KillRat(extraData.rat_eid!);
if (innate) innate.ApplyDebuff(target);
ApplyDamage({
attacker: caster,
victim: target,
damage: this.GetSpecialValueFor("damage"),
damage_type: this.GetAbilityDamageType(),
ability: this
})
target.AddNewModifier(caster, this, "modifier_sai_rat_reconnaissance", {duration: vision_duration});
target.AddNewModifier(caster, this, "modifier_sai_rat_reconnaissance_slow", {duration: this.GetSpecialValueFor("slow_duration") * (1 - target.GetStatusResistance())});
EmitSoundOn("Hero_Sai.RatReconnaissance.Impact", target);
}
/****************************************/
KillRat(id: EntityIndex) {
let rat = EntIndexToHScript(id);
if (rat) {
let impact_fx = ParticleManager.CreateParticle("particles/units/heroes/sai/sai_rat_reconnaissance_impact.vpcf", ParticleAttachment.CUSTOMORIGIN, undefined);
ParticleManager.SetParticleControl(impact_fx, 0, rat.GetAbsOrigin());
ParticleManager.ReleaseParticleIndex(impact_fx);
StopSoundOn("Hero_Sai.RatReconnaissance.Rat", rat)
UTIL_Remove(rat)
}
}
}
@registerModifier()
export class modifier_sai_rat_reconnaissance extends BaseModifier
{
DeclareFunctions(){ return [
ModifierFunction.PROVIDES_FOW_POSITION,
]}
/****************************************/
GetModifierProvidesFOWVision(): 0 | 1 {
return 1;
}
}
@registerModifier()
export class modifier_sai_rat_reconnaissance_slow extends BaseModifier
{
move_slow?: number;
/****************************************/
OnCreated(params: object): void {
let ability = this.GetAbility();
this.move_slow = -ability!.GetSpecialValueFor("move_slow");
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.MOVESPEED_BONUS_PERCENTAGE
]}
/****************************************/
GetModifierMoveSpeedBonus_Percentage(): number {
return this.move_slow!;
}
}
@registerModifier()
export class modifier_sai_super_beast_drawing_rat extends BaseModifier
{
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.NO_HEALTH_BAR]: true,
[ModifierState.DISARMED]: true,
[ModifierState.NOT_ON_MINIMAP]: true,
[ModifierState.OUT_OF_GAME]: true,
[ModifierState.INVULNERABLE]: true,
};
}
}
|
jaden-young/NWR
|
src/vscripts/items/chakra_armor.d.ts
|
/** @noSelfInFile */
declare function chakraArmorChangeIcon(hero: CDOTA_BaseNPC_Hero, itemName: string): void;
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/raikage/raikage_lariat.ts
|
import { BaseAbility, BaseModifier, BaseModifierMotionHorizontal, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface kv {
x: number;
y: number;
z: number;
}
@registerAbility()
export class raikage_lariat extends BaseAbility
{
lightning_blade_fx?: ParticleID;
active_target?: CDOTA_BaseNPC;
/****************************************/
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/raikage/raikage_lariat_dash.vpcf", context);
PrecacheResource("particle", "particles/units/heroes/raikage/raikage_lariat_impact.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/raikage/game_sounds_raikage.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/raikage/game_sounds_vo_raikage.vsndevts", context);
}
/****************************************/
GetCastRange(location: Vector, target: CDOTA_BaseNPC | undefined): number {
return IsClient() ? super.GetCastRange(location, target) : 50000;
}
/****************************************/
OnAbilityPhaseStart(): boolean {
EmitSoundOn("VO_Hero_Raikage.Lariat.Cast", this.GetCaster());
return true;
}
/****************************************/
OnAbilityPhaseInterrupted(): void {
StopSoundOn("VO_Hero_Raikage.Lariat.Cast", this.GetCaster());
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let position = this.GetCursorPosition();
let origin = caster.GetAbsOrigin();
let range = this.GetSpecialValueFor("cast_range");
let distance = (position - origin as Vector).Length2D();
position = distance < range ? position : (position - origin as Vector).Normalized() * range + origin as Vector;
caster.AddNewModifier(caster, this, "modifier_raikage_lariat", {duration: -1, x: position.x, y: position.y, z: position.z})
EmitSoundOn("Hero_Raikage.Lariat.Cast", caster);
}
}
@registerModifier()
export class modifier_raikage_lariat extends BaseModifierMotionHorizontal
{
position?: Vector;
origin?: Vector;
damage?: number;
stun_duration?: number;
speed?: number;
search_radius?: number;
distance_to_cross?: number;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: kv): void {
let ability = this.GetAbility()!;
let parent = this.GetParent();
this.stun_duration = ability.GetSpecialValueFor("stun_duration");
this.speed = ability.GetSpecialValueFor("speed");
this.damage = ability.GetSpecialValueFor("damage") + parent.FindTalentValue("special_bonus_raikage_3");
this.search_radius = parent.GetPaddedCollisionRadius() * 2;
if (!IsServer()) return;
this.origin = parent.GetAbsOrigin();
this.position = Vector(params.x, params.y, params.z);
this.distance_to_cross = (this.position - parent!.GetAbsOrigin() as Vector).Length2D();
if (!this.ApplyHorizontalMotionController()) {
this.Destroy()
return;
}
let ground_fx = ParticleManager.CreateParticle("particles/units/heroes/raikage/raikage_lariat_dash.vpcf", ParticleAttachment.ABSORIGIN_FOLLOW, parent)
this.AddParticle(ground_fx, false, false, -1, false, false);
}
/****************************************/
OnDestroy(): void {
if (!IsServer()) return;
let parent = this.GetParent();
parent.RemoveHorizontalMotionController(this);
GridNav.DestroyTreesAroundPoint(parent.GetAbsOrigin(), this.search_radius!, true);
if(GridNav.IsBlocked(parent.GetAbsOrigin()))
FindClearSpaceForUnit(parent, parent.GetAbsOrigin(), false);
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.OVERRIDE_ANIMATION,
]}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.NO_UNIT_COLLISION]: true,
[ModifierState.FLYING_FOR_PATHING_PURPOSES_ONLY]: true,
};
}
/****************************************/
UpdateHorizontalMotion(parent: CDOTA_BaseNPC, dt: number): void {
let direction = (this.position! - parent.GetAbsOrigin() as Vector).Normalized();
if (this.CheckConditions() || this.CheckAreaForEnemies() || this.CheckDistance()) {
this.Destroy();
return;
}
parent.FaceTowards(this.position!);
parent.SetAbsOrigin(parent.GetAbsOrigin() + this.speed! * direction * dt as Vector);
}
/****************************************/
OnHorizontalMotionInterrupted(): void {
this.Destroy();
}
/****************************************/
GetOverrideAnimation(): GameActivity{
return GameActivity.DOTA_CAST_ABILITY_2;
}
/****************************************/
CheckConditions(): boolean {
let parent = this.GetParent();
if (parent.IsStunned() || parent.IsHexed() || parent.IsRooted()) {
return true;
}
return false;
}
/****************************************/
CheckAreaForEnemies(): boolean {
let parent = this.GetParent();
let enemies = FindUnitsInRadius(
parent.GetTeamNumber(),
parent.GetAbsOrigin(),
undefined,
this.search_radius!,
UnitTargetTeam.ENEMY,
UnitTargetType.BASIC + UnitTargetType.HERO,
UnitTargetFlags.NO_INVIS,
FindOrder.ANY,
false
);
for(let enemy of enemies){
if (this.IsFacingTarget(enemy)) {
let ability = this.GetAbility();
enemy.AddNewModifier(parent, ability, "modifier_stunned", {duration: this.stun_duration! * (1 - enemy.GetStatusResistance())});
ApplyDamage({
attacker: parent,
victim: enemy,
damage: this.damage!,
damage_type: ability!.GetAbilityDamageType(),
ability: ability
});
let impact_fx = ParticleManager.CreateParticle("particles/units/heroes/raikage/raikage_lariat_impact.vpcf", ParticleAttachment.ABSORIGIN, enemy);
ParticleManager.SetParticleControl(impact_fx, 3, enemy.GetAbsOrigin() + Vector(0, 0, 70) as Vector);
ParticleManager.ReleaseParticleIndex(impact_fx);
EmitSoundOn("Hero_Raikage.Lariat.Impact", enemy);
return true;
}
}
return false;
}
/****************************************/
CheckDistance(): boolean {
let parent = this.GetParent();
let distance = (parent.GetAbsOrigin() - this.origin! as Vector).Length2D()
if (distance >= this.distance_to_cross!) {
return true;
}
return false;
}
/****************************************/
IsFacingTarget(target: CDOTA_BaseNPC): boolean {
let direction = (target.GetAbsOrigin() - this.GetParent().GetAbsOrigin() as Vector).Normalized();
let parent_facing_direction = this.GetParent().GetForwardVector();
return parent_facing_direction.Dot(direction) > 0;
}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/raikage/lariat_aura.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN_FOLLOW;
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/hidan/hidan_taunt.ts
|
import { BaseAbility, BaseModifier, BaseModifierMotionHorizontal, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface kv {
x: number;
y: number;
z: number;
}
@registerAbility()
export class hidan_taunt extends BaseAbility
{
lightning_blade_fx?: ParticleID;
active_target?: CDOTA_BaseNPC;
/****************************************/
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/hero_axe/axe_beserkers_call_owner.vpcf", context);
PrecacheResource("particle", "particles/status_fx/status_effect_beserkers_call.vpcf", context);
PrecacheResource("particle", "particles/units/heroes/hidan/hidan_taunt_shard.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/hidan/game_sounds_hidan.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/hidan/game_sounds_vo_hidan.vsndevts", context);
}
/****************************************/
GetCastRange(location: Vector, target: CDOTA_BaseNPC | undefined): number {
return this.GetSpecialValueFor("radius") + this.GetCaster().FindTalentValue("special_bonus_hidan_1");
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let radius = this.GetSpecialValueFor("radius") + caster.FindTalentValue("special_bonus_hidan_1");
let duration = this.GetSpecialValueFor("duration");
let enemies = FindUnitsInRadius(
caster.GetTeamNumber(),
caster.GetAbsOrigin(),
undefined,
radius,
UnitTargetTeam.ENEMY,
UnitTargetType.BASIC + UnitTargetType.HERO,
UnitTargetFlags.MAGIC_IMMUNE_ENEMIES,
FindOrder.ANY,
false
);
enemies.forEach(enemy => {
enemy.AddNewModifier(caster, this, "modifier_hidan_taunt", {duration: duration * (1 - enemy.GetStatusResistance())});
});
caster.AddNewModifier(caster, this, "modifier_hidan_taunt_buff", {duration: this.GetSpecialValueFor("str_duration")});
EmitSoundOn("VO_Hero_Hidan.Taunt.Cast", caster);
EmitSoundOn("Hero_Hidan.Taunt.Cast", caster);
ParticleManager.ReleaseParticleIndex(
ParticleManager.CreateParticle("particles/units/heroes/hero_axe/axe_beserkers_call_owner.vpcf", ParticleAttachment.ABSORIGIN_FOLLOW, caster)
)
if (caster.HasShard()) caster.AddNewModifier(caster, this, "modifier_hidan_taunt_shard", {duration: this.GetSpecialValueFor("shard_duration")});
}
}
@registerModifier()
export class modifier_hidan_taunt extends BaseModifierMotionHorizontal
{
IsPurgable(): boolean {return false}
/****************************************/
OnCreated(params: object): void {
if (!IsServer()) return;
ExecuteOrderFromTable({
OrderType: UnitOrder.ATTACK_TARGET,
UnitIndex: this.GetParent().entindex(),
TargetIndex: this.GetCaster()?.entindex(),
Queue: false
})
this.GetParent().SetForceAttackTarget(this.GetCaster());
this.StartIntervalThink(0.1)
}
/****************************************/
OnIntervalThink(): void {
let caster = this.GetCaster()!;
if (!caster.IsAlive() || (caster.GetAbsOrigin() - this.GetParent().GetAbsOrigin() as Vector).Length2D() > 2000) {
this.Destroy();
}
}
/****************************************/
OnDestroy(): void {
if (!IsServer()) return;
this.GetParent().SetForceAttackTarget(undefined);
}
/****************************************/
GetStatusEffectName(): string {
return "particles/status_fx/status_effect_beserkers_call.vpcf";
}
/****************************************/
StatusEffectPriority(): ModifierPriority {
return ModifierPriority.HIGH;
}
}
@registerModifier()
export class modifier_hidan_taunt_buff extends BaseModifierMotionHorizontal
{
str_gain_hero?: number;
str_gain_not_hero?: number;
strength_gain_duration?: number;
/****************************************/
IsPurgable(): boolean {return false}
/****************************************/
OnCreated(params: kv): void {
let ability = this.GetAbility()!;
this.str_gain_hero = ability.GetSpecialValueFor("str_gain_hero");
this.str_gain_not_hero = ability.GetSpecialValueFor("str_gain_not_hero");
this.strength_gain_duration = ability.GetSpecialValueFor("duration");
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.ON_ATTACK_LANDED,
ModifierFunction.STATS_STRENGTH_BONUS
]}
/****************************************/
OnAttackLanded(event: ModifierAttackEvent): void {
if (!IsServer()) return;
let attacker = event.attacker;
let target = event.target;
if (target != this.GetParent() || this.GetElapsedTime() > this.strength_gain_duration!) return;
this.SetStackCount(this.GetStackCount() + (attacker.IsHero() ? this.str_gain_hero! : this.str_gain_not_hero!));
(target as CDOTA_BaseNPC_Hero).CalculateStatBonus(true);
}
/****************************************/
GetModifierBonusStats_Strength(): number {
return this.GetStackCount();
}
}
@registerModifier()
export class modifier_hidan_taunt_shard extends BaseModifierMotionHorizontal
{
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.MIN_HEALTH
]}
/****************************************/
GetMinHealth(): number {
return 1;
}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/hidan/hidan_taunt_shard.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN_FOLLOW;
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/kisame/kisame_water_prison.ts
|
import { BaseAbility, BaseModifier, BaseModifierMotionVertical, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface RisingMotionModifier extends CDOTA_Buff
{
SetFalling(): void;
}
@registerAbility()
export class kisame_water_prison extends BaseAbility
{
target?: CDOTA_BaseNPC_Hero;
/****************************************/
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/kisame/kisame_water_prison.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/kisame/game_sounds_kisame.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/kisame/game_sounds_vo_kisame.vsndevts", context);
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let target = this.GetCursorTarget();
let channel_time = this.GetChannelTime();
if (target?.TriggerSpellAbsorb(this)) return;
this.target = target as CDOTA_BaseNPC_Hero;
target?.AddNewModifier(caster, this, "modifier_kisame_water_prison", {duration: channel_time});
target?.AddNewModifier(caster, this, "modifier_kisame_water_prison_motion", {duration: channel_time + 0.6});
caster.AddNewModifier(caster, this, "modifier_kisame_water_prison_resistance", {duration: channel_time});
EmitSoundOn("Hero_Kisame.WaterPrison.Target", target!);
EmitSoundOn("Hero_Kisame.WaterPrison.Target.Loop", target!);
}
/****************************************/
OnChannelFinish(interrupted: boolean): void {
let caster = this.GetCaster();
this.target?.RemoveModifierByNameAndCaster("modifier_kisame_water_prison", caster);
let motion_modifier = this.target!.FindModifierByName("modifier_kisame_water_prison_motion") as RisingMotionModifier;
if (motion_modifier) {
motion_modifier.SetFalling();
}
EmitSoundOn("Hero_Kisame.WaterPrison.Burst", this.target!);
Timers.CreateTimer(FrameTime(), () =>
StopSoundOn("Hero_Kisame.WaterPrison.Target.Loop", this.target!)
)
}
}
@registerModifier()
export class modifier_kisame_water_prison extends BaseModifierMotionVertical
{
damage_per_second?: number;
interval?: number;
damage_table?: ApplyDamageOptions;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: Object): void {
let ability = this.GetAbility()!;
let parent = this.GetParent();
this.interval = ability.GetSpecialValueFor("interval");
this.damage_per_second = ability.GetSpecialValueFor("damage_per_second") * this.interval;
if (!IsServer()) return;
this.damage_table = {
attacker: this.GetCaster()!,
victim: parent,
damage: this.damage_per_second,
damage_type: this.GetAbility()?.GetAbilityDamageType()!,
ability: this.GetAbility()
}
this.StartIntervalThink(this.interval);
this.OnIntervalThink();
let prison_fx = ParticleManager.CreateParticle("particles/units/heroes/kisame/kisame_water_prison.vpcf", ParticleAttachment.ABSORIGIN_FOLLOW, parent);
ParticleManager.SetParticleControlEnt(prison_fx, 0, parent, ParticleAttachment.POINT_FOLLOW, "attach_hitloc", parent.GetAbsOrigin(), true);
this.AddParticle(prison_fx, false, false, -1, false, false);
}
/****************************************/
OnIntervalThink(): void {
ApplyDamage(this.damage_table!);
}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.PROVIDES_VISION]: true,
[ModifierState.STUNNED]: true,
[ModifierState.SILENCED]: true
};
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.OVERRIDE_ANIMATION,
ModifierFunction.TOOLTIP,
ModifierFunction.TOOLTIP2
]}
/****************************************/
GetOverrideAnimation(): GameActivity {
return GameActivity.DOTA_FLAIL
}
/****************************************/
OnTooltip(): number {
return this.damage_per_second!;
}
/****************************************/
OnTooltip2(): number {
return this.interval!;
}
}
interface RisingMotionModifier extends BaseModifierMotionVertical
{
SetFalling(): void;
}
@registerModifier()
export class modifier_kisame_water_prison_motion extends BaseModifierMotionVertical
{
is_rising: boolean = true;
steps: number = 0;
max_offset: number = 0;
/****************************************/
IsHidden(): boolean {return true}
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: object): void {
if (!IsServer()) return;
if (!this.ApplyVerticalMotionController()) {
this.Destroy()
return;
}
}
/****************************************/
OnDestroy(): void {
if (!IsServer()) return;
this.GetParent().RemoveVerticalMotionController(this);
}
/****************************************/
SetFalling(): void {
this.steps = 0.3 / FrameTime();
this.is_rising = false;
}
/****************************************/
UpdateVerticalMotion(me: CDOTA_BaseNPC, dt: number): void {
let origin = me.GetAbsOrigin();
let offset = this.is_rising ? 50 : -this.max_offset / this.steps;
me.SetAbsOrigin(origin + Vector(0, 0, offset) * dt as Vector);
this.max_offset = this.is_rising ? offset * this.steps : this.max_offset;
this.is_rising ? this.steps++ : this.steps--;
if (!this.is_rising && this.steps < 5) this.Destroy();
}
/****************************************/
OnVerticalMotionInterrupted(): void {
this.Destroy();
}
}
@registerModifier()
export class modifier_kisame_water_prison_resistance extends BaseModifier
{
damage_reduction?: number;
/****************************************/
OnCreated(params: object): void {
this.damage_reduction = -this.GetAbility()!.GetSpecialValueFor("damage_reduction");
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.INCOMING_DAMAGE_PERCENTAGE
]}
/****************************************/
GetModifierIncomingDamage_Percentage(): number {
return this.damage_reduction!;
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/itachi/itachi_amaterasu.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class itachi_amaterasu extends BaseAbility
{
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/itachi/ephemeral.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/itachi/game_sounds_itachi.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/itachi/game_sounds_vo_itachi.vsndevts", context);
}
/****************************************/
GetAOERadius(): number {
return this.GetSpecialValueFor("radius");
}
/****************************************/
OnAbilityPhaseStart(): boolean {
EmitSoundOn("VO_Hero_Itachi.Amaterasu.Cast", this.GetCaster());
EmitSoundOn("Hero_Itachi.Amaterasu.Build", this.GetCaster());
return true
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let position = this.GetCursorPosition();
let duration = this.GetSpecialValueFor("duration")
CreateModifierThinker(caster, this, "modifier_itachi_amaterasu", {duration: duration}, position, caster.GetTeamNumber(), false);
EmitSoundOn("Hero_Itachi.Amaterasu.Fire", caster);
}
}
@registerModifier()
export class modifier_itachi_amaterasu extends BaseModifier
{
radius: number = 0;
burn_duration?: number;
/****************************************/
IsAura(): boolean {return true}
GetAuraRadius(): number {return this.radius}
GetAuraSearchTeam(): UnitTargetTeam {return UnitTargetTeam.ENEMY}
GetAuraSearchType(): UnitTargetType {return UnitTargetType.BASIC + UnitTargetType.HERO}
GetModifierAura(): string {return "modifier_itachi_amaterasu_proximity"}
/****************************************/
OnCreated(params: object): void {
if (!IsServer()) return;
let parent = this.GetParent();
let ability = this.GetAbility();
let duration = ability!.GetSpecialValueFor("duration");
this.radius = ability!.GetSpecialValueFor("radius");
this.burn_duration = ability!.GetSpecialValueFor("burn_duration");
let amaterasu_fx = ParticleManager.CreateParticle("particles/units/heroes/itachi/amaterasu.vpcf", ParticleAttachment.ABSORIGIN, this.GetCaster());
ParticleManager.SetParticleControl(amaterasu_fx, 0, parent.GetAbsOrigin());
ParticleManager.SetParticleControl(amaterasu_fx, 1, parent.GetAbsOrigin());
ParticleManager.SetParticleControl(amaterasu_fx, 2, Vector(duration, 0, 0));
ParticleManager.SetParticleControl(amaterasu_fx, 3, Vector(this.radius, 0, 0));
this.AddParticle(amaterasu_fx, false, false, -1, false, false);
EmitSoundOn("Hero_Itachi.Amaterasu.BurnArea", this.GetParent());
this.StartIntervalThink(1);
this.OnIntervalThink();
}
OnDestroy(): void {
if (!IsServer()) return;
StopSoundOn("Hero_Itachi.Amaterasu.BurnArea", this.GetParent());
}
OnIntervalThink(): void {
let parent = this.GetParent();
let enemies = FindUnitsInRadius(parent.GetTeamNumber(),
parent.GetAbsOrigin(),
undefined, this.radius,
UnitTargetTeam.ENEMY,
UnitTargetType.BASIC + UnitTargetType.HERO,
UnitTargetFlags.NONE,
FindOrder.ANY,
false
);
enemies.forEach(enemy => {
enemy.AddNewModifier(this.GetCaster(), this.GetAbility(), "modifier_itachi_amaterasu_burn", {duration: this.burn_duration});
});
}
}
@registerModifier()
export class modifier_itachi_amaterasu_burn extends BaseModifier
{
high_damage?: number;
low_damage?: number;
damage_table?: ApplyDamageOptions;
/****************************************/
OnCreated(params: object): void {
let ability = this.GetAbility();
let caster = this.GetCaster();
let interval = ability!.GetSpecialValueFor("interval");
this.high_damage = (ability!.GetSpecialValueFor("damage_per_second") + caster!.FindTalentValue("special_bonus_itachi_7")) * interval;
this.low_damage = ability!.GetSpecialValueFor("burn_dps") * interval;
if (!IsServer()) return;
this.damage_table = {
attacker: this.GetCaster() as CDOTA_BaseNPC,
victim: this.GetParent(),
damage: this.high_damage,
damage_type: ability!.GetAbilityDamageType(),
ability: ability
}
this.StartIntervalThink(interval);
this.OnIntervalThink();
}
/****************************************/
OnIntervalThink(): void {
this.damage_table!.damage = this.IsInsideFlames() ? this.high_damage! : this.low_damage!;
ApplyDamage(this.damage_table!);
SendOverheadEventMessage(undefined, OverheadAlert.BONUS_SPELL_DAMAGE, this.GetParent(), this.damage_table!.damage * (1 + this.GetCaster()!.GetSpellAmplification(false)), undefined);
EmitSoundOn("Hero_Itachi.Amaterasu.BurnLayer", this.GetParent());
}
/****************************************/
IsInsideFlames(): boolean {
return this.GetParent().HasModifier("modifier_itachi_amaterasu_proximity");
}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/itachi/amaterasu_burn.vpcf"
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN_FOLLOW
}
}
@registerModifier()
export class modifier_itachi_amaterasu_proximity extends BaseModifier
{
IsHidden(): boolean {return true}
IsPurgable(): boolean {return false}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/itachi/itachi_tsukuyomi.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class itachi_tsukuyomi extends BaseAbility
{
target?: CDOTA_BaseNPC_Hero;
/****************************************/
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/hero_bane/bane_fiends_grip.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/itachi/game_sounds_itachi.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/itachi/game_sounds_vo_itachi.vsndevts", context);
}
/****************************************/
Spawn(): void {
if (!IsServer() || !this.GetCaster().IsRealHero()) return;
ListenToGameEvent("dota_player_learned_ability", (event) => this.OnPlayerLearnedAbility(event), undefined);
}
/****************************************/
OnPlayerLearnedAbility(event: DotaPlayerLearnedAbilityEvent): void {
let hero = PlayerResource.GetSelectedHeroEntity(event.PlayerID);
let ability_name = event.abilityname;
if (this == undefined || this.IsNull() || this.GetCaster() == undefined || hero == undefined) return;
if (hero != this.GetCaster() || ability_name != "itachi_amaterasu") return;
this.SetLevel(this.GetCaster().FindAbilityByName("itachi_amaterasu")!.GetLevel());
}
/****************************************/
OnUpgrade(): void {
let amaterasu_ability = this.GetCaster().FindAbilityByName("itachi_amaterasu")
if (amaterasu_ability) amaterasu_ability.SetLevel(this.GetLevel());
}
/****************************************/
GetChannelTime(): number {
return super.GetChannelTime() + this.GetCaster()!.FindTalentValue("special_bonus_itachi_6");
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let target = this.GetCursorTarget();
let channel_time = this.GetChannelTime();
if (target?.TriggerSpellAbsorb(this)) return;
this.target = target as CDOTA_BaseNPC_Hero;
target?.AddNewModifier(caster, this, "modifier_itachi_tsukuyomi", {duration: channel_time});
EmitSoundOn("Hero_Itachi.Tsukuyomi.Channel", this.target);
EmitSoundOn("Hero_Itachi.Tsukuyomi.Cast", this.target);
EmitSoundOn("VO_Hero_Itachi.Tsukuyomi.Cast", caster);
}
/****************************************/
OnChannelFinish(interrupted: boolean): void {
let caster = this.GetCaster();
this.target?.RemoveModifierByNameAndCaster("modifier_itachi_tsukuyomi", caster);
if (interrupted && this.target?.IsAlive()) StopSoundOn("Hero_Itachi.Tsukuyomi.Channel", this.target!);
}
}
@registerModifier()
export class modifier_itachi_tsukuyomi extends BaseModifier
{
damage_per_second?: number;
mana_drain?: number;
interval?: number;
target_facing_mult?: number;
angle?: number;
damage_table?: ApplyDamageOptions;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return true}
/****************************************/
OnCreated(params: Object): void {
let ability = this.GetAbility()!;
this.interval = ability.GetSpecialValueFor("interval");
this.damage_per_second = ability.GetSpecialValueFor("damage_per_second") * this.interval;
this.mana_drain = ability.GetSpecialValueFor("mana_drain") * this.interval;
this.target_facing_mult = ability.GetSpecialValueFor("target_facing_mult");
this.angle = ability.GetSpecialValueFor("angle");
if (!IsServer()) return;
this.damage_table = {
attacker: this.GetCaster()!,
victim: this.GetParent(),
damage: this.damage_per_second,
damage_type: this.GetAbility()?.GetAbilityDamageType()!,
ability: this.GetAbility()
}
this.StartIntervalThink(this.interval);
this.OnIntervalThink();
}
OnDestroy(): void {
if (!IsServer()) return;
//this.OnIntervalThink();
}
OnIntervalThink(): void {
let is_facing_caster = this.IsFacingCaster()
let parent = this.GetParent();
let mana_drain = is_facing_caster ? this.mana_drain! * this.target_facing_mult! : this.mana_drain as number;
this.damage_table!.damage = is_facing_caster ? this.damage_per_second! * this.target_facing_mult! : this.damage_per_second as number;
let mana_to_drain = parent.GetMaxMana() * mana_drain / 100;
ApplyDamage(this.damage_table!);
parent.ReduceMana(mana_to_drain);
this.GetCaster()?.GiveMana(mana_to_drain);
}
IsFacingCaster(): boolean {
let caster = this.GetCaster()!
let parent = this.GetParent()
let direction = -caster.GetForwardVector() as Vector;
let parent_direction = parent.GetForwardVector();
return parent_direction.Dot(direction) > 1 - (this.angle!/180);
}
/****************************************/
CheckState(): Partial<Record<ModifierState, boolean>> {
return {
[ModifierState.PROVIDES_VISION]: true,
[ModifierState.STUNNED]: true,
[ModifierState.SILENCED]: true
};
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.OVERRIDE_ANIMATION,
ModifierFunction.TOOLTIP,
ModifierFunction.TOOLTIP2
]}
/****************************************/
GetOverrideAnimation(): GameActivity {
return GameActivity.DOTA_FLAIL
}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/hero_bane/bane_fiends_grip.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN_FOLLOW;
}
/****************************************/
OnTooltip(): number {
return this.mana_drain!;
}
/****************************************/
OnTooltip2(): number {
return this.interval!;
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/guy/guy_innate_passive.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class guy_innate_passive extends BaseAbility
{
OnUpgrade(): void {
//Should refresh modifier on eanch upgrade
this.GetCaster().FindModifierByName(this.GetIntrinsicModifierName())?.ForceRefresh()
}
GetIntrinsicModifierName(): string {
return "modifier_guy_innate_passive_intrinsic"
}
}
@registerModifier()
export class modifier_guy_innate_passive_intrinsic extends BaseModifier {
status_resistance_per_percentage_hp_missing?: number;
IsDebuff(): boolean {
return false
}
IsHidden(): boolean {
return false
}
OnCreated(params: object): void {
this.status_resistance_per_percentage_hp_missing = this.GetAbility()?.GetSpecialValueFor("status_resistance_per_percentage_hp_missing")
}
OnRefresh(params: object): void {
this.status_resistance_per_percentage_hp_missing = this.GetAbility()?.GetSpecialValueFor("status_resistance_per_percentage_hp_missing")
}
DeclareFunctions() {
return [ModifierFunction.STATUS_RESISTANCE]
}
GetModifierStatusResistance() {
return (100 - (this.GetParent().GetHealthPercent())) * (this.status_resistance_per_percentage_hp_missing ?? 0)
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/onoki/onoki_weighted_boulder.ts
|
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface extra
{
fx_id?: ParticleID;
}
@registerAbility()
export class onoki_weighted_boulder extends BaseAbility {
rock_fx?: ParticleID;
/****************************************/
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/onoki/onoki_weighted_boulder_technique.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/onoki/game_sounds_onoki.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/onoki/game_sounds_vo_onoki.vsndevts", context);
}
/****************************************/
GetAOERadius(): number {
return this.GetSpecialValueFor("radius");
}
/****************************************/
OnAbilityPhaseStart(): boolean {
let caster = this.GetCaster();
let position = this.GetCursorPosition();
let direction = position - caster.GetAbsOrigin() as Vector;
direction.z = 0;
direction = direction.Normalized();
this.rock_fx = ParticleManager.CreateParticle("particles/units/heroes/onoki/onoki_weighted_boulder_technique.vpcf", ParticleAttachment.ABSORIGIN, caster);
ParticleManager.SetParticleControl(this.rock_fx, 0, caster.GetAttachmentOrigin(caster.ScriptLookupAttachment("attach_hitloc")) + direction * 125 as Vector);
EmitSoundOn("Hero_Onoki.WeightedBoulder.Precast", caster);
return true;
}
/****************************************/
OnAbilityPhaseInterrupted(): void {
ParticleManager.DestroyParticle(this.rock_fx!, true);
ParticleManager.ReleaseParticleIndex(this.rock_fx!);
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let position = this.GetCursorPosition();
let origin = caster.GetAbsOrigin();
let speed = this.GetSpecialValueFor("speed");
let min_distance = this.GetSpecialValueFor("min_range");
let distance = (position - caster.GetAbsOrigin() as Vector).Length2D();
let fx_id = this.rock_fx;
let direction = position - caster.GetAbsOrigin() as Vector;
direction.z = 0;
direction = direction.Normalized();
position = distance >= min_distance ? position : direction * min_distance + origin as Vector;
ProjectileManager.CreateLinearProjectile({
Ability: this,
EffectName: "",
vSpawnOrigin: caster.GetAttachmentOrigin(caster.ScriptLookupAttachment("attach_hitloc")) as Vector,
fDistance: (position - origin as Vector).Length2D(),
Source: caster,
iUnitTargetTeam: UnitTargetTeam.NONE,
vVelocity: direction * speed as Vector,
ExtraData: {
fx_id: fx_id
}
});
EmitSoundOn("Hero_Onoki.WeightedBoulder.Cast", caster);
ParticleManager.SetParticleControl(fx_id!, 1, GetGroundPosition(position, undefined) + Vector(0, 0, 75) as Vector);
ParticleManager.SetParticleControl(fx_id!, 2, Vector(speed, 0, 0));
}
/****************************************/
OnProjectileHit_ExtraData(target: CDOTA_BaseNPC | undefined, location: Vector, extraData: extra): boolean | void {
if (target || !this || this.IsNull()) return;
let caster = this.GetCaster()
let radius = this.GetSpecialValueFor("radius");
let duration = this.GetSpecialValueFor("stun_duration_per_armor") * caster.GetPhysicalArmorValue(false);
let damage = this.GetSpecialValueFor("damage_per_armor") * caster.GetPhysicalArmorValue(false);
let fx_id = extraData.fx_id;
let damage_table : ApplyDamageOptions = {
attacker: caster,
victim: caster,
damage: damage,
damage_type: this.GetAbilityDamageType(),
ability: this
}
let enemies = FindUnitsInRadius(
caster.GetTeamNumber(),
location,
undefined,
radius,
UnitTargetTeam.ENEMY,
UnitTargetType.BASIC + UnitTargetType.HERO,
UnitTargetFlags.NONE,
FindOrder.ANY,
false
);
enemies.forEach(enemy => {
damage_table.victim = enemy;
ApplyDamage(damage_table);
enemy.AddNewModifier(caster, this, "modifier_stunned", {duration: duration * (1 - enemy.GetStatusResistance())});
EmitSoundOn("Hero_Onoki.WeightedBoulder.Stun", enemy);
});
EmitSoundOnLocationWithCaster(location, "Hero_Onoki.WeightedBoulder.Impact", caster);
ParticleManager.DestroyParticle(fx_id!, false);
ParticleManager.ReleaseParticleIndex(fx_id!);
}
}
|
jaden-young/NWR
|
src/vscripts/GameMode.ts
|
import { reloadable } from "./lib/tstl-utils";
import { modifier_panic } from "./modifiers/modifier_panic";
import "./extended_api";
import "./items";
import "./lib/rescale";
import "./lib/timers";
import "./lib/popups";
import "./lib/keyvalues";
import "./lib/vanilla_extension"
import "./lib/vector_targeting_interface"
import { ShortHeroName } from "./lib/util";
import "./components/lul/label";
// imports that are only here to get lua libs into game/
import "./modifiers/modifier_generic_custom_indicator";
import "./lib/adv_log";
import "./lib/better_cooldown";
import "./components/barebones/physics";
import "./components/barebones/util";
import "./components/voicelines/voicelines";
import { malulubul } from "./components/lul/malubulul";
// include to print all event data in console, also uncomment in RegisterGameEvents
// import "./components/barebones/eventtest";
//Importing lua libraries
require("components/garbage_collector");
require("lib/vector_targeting");
// TODO: Fix barebones editing gamemode object
// require("components/barebones/events")
require("modifiers/modifier_responses");
require("components/demo/init");
const heroSelectionTime = 20;
declare global {
interface CDOTAGameRules {
Addon: GameMode;
}
}
@reloadable
export class GameMode {
Game: CDOTABaseGameMode = GameRules.GetGameModeEntity();
/**
* Set of heroes that have spawned in the game at least once.
*/
spawned_heros: Set<string> = new Set();
public static Precache(this: void, context: CScriptPrecacheContext) {
PrecacheResource("particle", "particles/ui_mouseactions/range_finder_cone.vpcf", context);
PrecacheResource("soundfile", "soundevents/music/nwr_team_selection.vsndevts", context);
PrecacheResource("soundfile", "soundevents/music/nwr_hero_selection.vsndevts", context);
PrecacheResource("soundfile", "soundevents/heroes/kakashi_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/haku_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/hidan_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/zabuza_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/madara_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/kisame_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/gaara_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/yondaime_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/naruto_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/neji_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/guy_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/onoki_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/raikage_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/sai_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/sakura_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/sasuke_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/shikamaru_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/temari_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/anko_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/itachi_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/heroes/shisui_soundevents.vsndevts", context)
PrecacheResource("soundfile", "soundevents/global/akat_start.vsndevts", context)
PrecacheResource("soundfile", "soundevents/global/shinobi_start.vsndevts", context)
PrecacheResource("soundfile", "soundevents/global/malulubul.vsndevts", context)
PrecacheResource("soundfile", "soundevents/global/overridden_sounds.vsndevts", context)
PrecacheResource("soundfile", "soundevents/clones/clone_pop.vsndevts", context)
PrecacheResource( "model", "models/striker_gaara/striker_gaara_gourd.vmdl", context )
PrecacheModel("models/striker_gaara/striker_gaara_gourd.vmdl", context)
// PrecacheResource("soundfile", "soundevents/itachi_crows.vsndevts", context)
// PrecacheResource("soundfile", "soundevents/itachi_amateratsu.vsndevts", context)
// PrecacheResource("soundfile", "soundevents/itachi_amateratsu_burning.vsndevts", context)
// PrecacheResource("soundfile", "soundevents/naruto_rasen_shuriken.vsndevts", context)
// PrecacheResource("soundfile", "soundevents/naruto_kills_sasuke.vsndevts", context)
// PrecacheResource("soundfile", "soundevents/sasuke_kills_naruto.vsndevts", context)
// PrecacheResource("soundfile", "soundevents/sasuke_kills_gaara.vsndevts", context)
// PrecacheResource("soundfile", "soundevents/sasuke_kills_itachi.vsndevts", context)
// PrecacheResource("soundfile", "soundevents/madara_trees.vsndevts", context)
// This call probably belongs somewhere else, but this is where the old
// repo had it so it was ported directly. Feel free to move/remove it
// after testing.
LinkLuaModifier("modifier_custom_mechanics", "modifiers/modifier_custom_mechanics", LuaModifierMotionType.NONE);
}
public static Activate(this: void) {
// When the addon activates, create a new instance of this GameMode class.
GameRules.Addon = new GameMode();
}
constructor() {
this.configure();
}
configure() {
this.RegisterEvents();
this.RegisterGameRules();
}
RegisterEvents() {
ListenToGameEvent("game_rules_state_change", () => this.OnStateChange(), undefined);
ListenToGameEvent("npc_spawned", event => this.OnNpcSpawned(event), undefined);
ListenToGameEvent("dota_player_learned_ability", event => this.OnPlayerLearnedAbility(event), undefined);
ListenToGameEvent("entity_killed", event => this.OnEntityKilled(event), undefined);
ListenToGameEvent("dota_item_purchased", event => this.OnDotaItemPurchased(event), undefined);
ListenToGameEvent("dota_player_pick_hero", event => this.OnPlayerPickHero(event), undefined);
ListenToGameEvent("player_chat", event => this.OnPlayerChat(event), undefined);
ListenToGameEvent("dota_player_gained_level", event => this.OnPlayerGainedLevel(event), undefined);
// Uncomment to print all event data
// EventTest.StartEventTest();
// Register event listeners for events from the UI
CustomGameEventManager.RegisterListener("ui_panel_closed", (_, data) => {
print(`Player ${data.PlayerID} has closed their UI panel.`);
// Respond by sending back an example event
const player = PlayerResource.GetPlayer(data.PlayerID)!;
CustomGameEventManager.Send_ServerToPlayer(player, "example_event", {
myNumber: 42,
myBoolean: true,
myString: "Hello!",
myArrayOfNumbers: [1.414, 2.718, 3.142]
});
});
}
RegisterGameRules() {
this.Game.SetRecommendedItemsDisabled(false);
this.Game.SetCameraDistanceOverride(1134.0);
this.Game.SetCustomBuybackCostEnabled(false);
this.Game.SetCustomBuybackCooldownEnabled(false);
this.Game.SetBuybackEnabled(true);
this.Game.SetTopBarTeamValuesOverride(true);
this.Game.SetTopBarTeamValuesVisible(true);
this.Game.SetUseCustomHeroLevels(false);
this.Game.SetCustomHeroMaxLevel(25);
this.Game.SetBotThinkingEnabled(false);
this.Game.SetTowerBackdoorProtectionEnabled(true);
this.Game.SetFogOfWarDisabled(false);
this.Game.SetGoldSoundDisabled(false);
this.Game.SetRemoveIllusionsOnDeath(false);
this.Game.SetAlwaysShowPlayerInventory(false);
this.Game.SetAnnouncerDisabled(false);
// -1 = default
this.Game.SetFixedRespawnTime(-1);
this.Game.SetFountainConstantManaRegen(-1);
this.Game.SetFountainPercentageHealthRegen(-1);
this.Game.SetFountainPercentageManaRegen(-1);
this.Game.SetLoseGoldOnDeath(true);
this.Game.SetMaximumAttackSpeed(600);
this.Game.SetMinimumAttackSpeed(20);
this.Game.SetStashPurchasingDisabled(false);
this.Game.SetRuneEnabled(RuneType.DOUBLEDAMAGE, true);
this.Game.SetRuneEnabled(RuneType.HASTE, true);
this.Game.SetRuneEnabled(RuneType.ILLUSION, true);
this.Game.SetRuneEnabled(RuneType.INVISIBILITY, true);
this.Game.SetRuneEnabled(RuneType.REGENERATION, true);
this.Game.SetRuneEnabled(RuneType.BOUNTY, true);
// TODO: other rune types?
this.Game.SetFreeCourierModeEnabled(true);
GameRules.SetHeroRespawnEnabled(true);
GameRules.SetUseUniversalShopMode(false);
GameRules.SetSameHeroSelectionEnabled(false);
GameRules.SetHeroSelectionTime(heroSelectionTime);
GameRules.SetPreGameTime(90);
GameRules.SetPostGameTime(60);
GameRules.SetTreeRegrowTime(60);
GameRules.SetUseCustomHeroXPValues(false);
GameRules.SetGoldPerTick(1);
GameRules.SetGoldTickTime(0.6);
GameRules.SetUseBaseGoldBountyOnHeroes(false);
GameRules.SetHeroMinimapIconScale(1);
GameRules.SetCreepMinimapIconScale(1);
GameRules.SetRuneMinimapIconScale(1);
GameRules.SetShowcaseTime(0);
GameRules.SetCustomGameTeamMaxPlayers(DotaTeam.GOODGUYS, 5);
GameRules.SetCustomGameTeamMaxPlayers(DotaTeam.BADGUYS, 5);
GameRules.SetFirstBloodActive(true);
GameRules.SetHideKillMessageHeaders(false);
GameRules.SetCustomGameTeamMaxPlayers(DotaTeam.GOODGUYS, 5);
GameRules.SetCustomGameTeamMaxPlayers(DotaTeam.BADGUYS, 5);
SetTeamCustomHealthbarColor(DotaTeam.GOODGUYS, 101, 212, 19);
SetTeamCustomHealthbarColor(DotaTeam.BADGUYS, 243, 201, 9);
if (GetMapName() == "turbo") {
GameRules.SetStartingGold(600);
GameRules.SetPreGameTime(40);
GameRules.SetUseUniversalShopMode(true);
this.Game.SetFixedRespawnTime(30);
this.Game.SetFountainConstantManaRegen(60);
this.Game.SetFountainPercentageHealthRegen(7);
this.Game.SetFountainPercentageManaRegen(5);
}
}
public OnStateChange(): void {
const state = GameRules.State_Get();
// Add 4 bots to lobby in tools
// if (IsInToolsMode() && state == GameState.CUSTOM_GAME_SETUP) {
// for (let i = 0; i < 4; i++) {
// Tutorial.AddBot("npc_dota_hero_lina", "", "", false);
// }
// }
if (state === GameState.CUSTOM_GAME_SETUP) {
VoiceResponses.Start();
EmitGlobalSound("CustomMusic.nwr_team_selection");
Rescale.RescaleBuildings();
// Automatically skip setup in tools
// NO! Enjoy the new song a couple times :)
// if (IsInToolsMode()) {
// Timers.CreateTimer(3, () => {
// GameRules.FinishCustomGameSetup();
// });
// }
}
if (state == GameState.HERO_SELECTION) {
StopGlobalSound("CustomMusic.nwr_team_selection");
EmitGlobalSound("CustomMusic.nwr_hero_selection");
}
if(state == GameState.STRATEGY_TIME) {
Rescale.RescaleShops();
for (let i = 0; i < PlayerResource.GetPlayerCount(); i++) {
if (PlayerResource.IsValidPlayer(i)) {
const player = PlayerResource.GetPlayer(i);
if (player == undefined) return;
if (!PlayerResource.HasSelectedHero(i)) {
player.MakeRandomHeroSelection();
}
const hero_name = PlayerResource.GetSelectedHeroName(i);
CustomGameEventManager.Send_ServerToPlayer(player, "set_strategy_time_hero_model", { hero_name });
}
}
}
// Start game once pregame hits
if (state === GameState.PRE_GAME) {
StopGlobalSound("CustomMusic.nwr_hero_selection");
Timers.CreateTimer(0.2, () => this.StartGame());
}
}
private StartGame(): void {
print("Game starting!");
// Do some stuff here
}
// Called on script_reload
public Reload() {
print("Script reloaded!");
// Do some stuff here
}
private OnNpcSpawned(event: NpcSpawnedEvent) {
const unit = EntIndexToHScript(event.entindex) as CDOTA_BaseNPC; // Cast to npc since this is the 'npc_spawned' event
if (!unit || unit.GetClassname() == "npc_dota_thinker" || unit.IsPhantom()) {
return;
}
Rescale.RescaleUnit(unit);
if (unit.IsRealHero()) {
const shortName = ShortHeroName(unit.GetUnitName());
if (!this.spawned_heros.has(shortName)) {
this.OnHeroInGame(unit);
this.spawned_heros.add(shortName);
}
}
}
/**
* Call only once when a hero first enters the game, and don't call again.
*/
OnHeroInGame(hero: CDOTA_BaseNPC_Hero) {
const playerId = hero.GetPlayerOwnerID();
const longName = hero.GetUnitName();
const shortName = ShortHeroName(longName);
const configFile = `scripts/vscripts/components/voicelines/keyvalues/${ShortHeroName(longName)}_responses.txt`;
hero.AddNewModifier(hero, undefined, "modifier_custom_mechanics", undefined);
VoiceResponses.RegisterUnit(longName, configFile);
CreateEmptyTalents(shortName);
if (hero.GetTeamNumber() == 2) {
print("shinobi start")
EmitSoundOnEntityForPlayer("shinobi_start", hero, playerId);
} else {
print("akat start")
EmitSoundOnEntityForPlayer("akat_start", hero, playerId);
}
CustomGameEventManager.Send_ServerToAllClients("override_hero_image", {});
//Innate passives bit
const innate_ability = hero.FindAbilityByName(`${shortName}_innate_passive`);
if(innate_ability){
innate_ability.SetLevel(1)
}
}
OnPlayerLearnedAbility(event: DotaPlayerLearnedAbilityEvent) {
// necessary for barebones talent logic
if (event.abilityname.includes("special_bonus_")) {
const player = EntIndexToHScript(event.player as EntityIndex) as CDOTAPlayerController;
const hero = player.GetAssignedHero();
const modifierName = `modifier_${event.abilityname}`;
hero.AddNewModifier(hero, undefined, modifierName, undefined);
}
}
OnEntityKilled(event: EntityKilledEvent): void {
if (this.Game.GetTopBarTeamValuesOverride()) {
GameRules.GetGameModeEntity().SetTopBarTeamValue(DotaTeam.BADGUYS, GetTeamHeroKills(DotaTeam.BADGUYS));
GameRules.GetGameModeEntity().SetTopBarTeamValue(DotaTeam.GOODGUYS, GetTeamHeroKills(DotaTeam.GOODGUYS));
}
const killer = EntIndexToHScript(event.entindex_attacker);
const killed = EntIndexToHScript(event.entindex_killed);
if (killer != undefined && killed != undefined) {
SupportItemCooldownReset(killed, killer);
}
if (!killer?.IsBaseNPC() || !killer.IsRealHero() || !killed?.IsBaseNPC()) {
return;
}
const team_id = killer.GetTeamNumber();
const killer_id = killer.GetPlayerID();
const victim_team_id = killer.GetTeamNumber();
if (!killed.IsReincarnating() && killed.IsRealHero()) {
const victim_id = killed.GetPlayerID();
CustomGameEventManager.Send_ServerToAllClients("hero_killed", { victim_team_id, victim_id, team_id, killer_id });
return;
}
if (killed.IsCreep()) {
const evtType = team_id == victim_team_id ? "deny" : "lasthit";
const data = { team_id, killer_id };
CustomGameEventManager.Send_ServerToAllClients(evtType, data);
return;
}
}
OnDotaItemPurchased(event: DotaItemPurchasedEvent): void {
if (event.itemname == "item_forehead_protector") {
const player = PlayerResource.GetPlayer(event.PlayerID);
const hero = player?.GetAssignedHero();
if (hero != undefined) {
ForeheadProtectorOnItemPickedUp(hero, event.itemname);
}
}
if (event.itemname == "item_flying_courier") {
Timers.CreateTimer(0.5, () => {
const courier = Entities.FindByModel(undefined, "models/props_gameplay/donkey_wings.vmdl") as CDOTA_Unit_Courier | undefined;
courier?.SetModelScale(1.2);
return undefined;
})
}
if (event.itemname == "courier_radiant_flying") {
Timers.CreateTimer(0.5, () => {
const courier = Entities.FindByModel(undefined, "models/props_gameplay/donkey_dire.vmdl") as CDOTA_Unit_Courier | undefined;
courier?.SetModelScale(1.2);
return undefined;
})
}
}
OnDotaItemCombined(event: DotaItemCombinedEvent): void {
if (event.itemname == "item_chakra_armor") {
const player = PlayerResource.GetPlayer(event.PlayerID);
const hero = player?.GetAssignedHero();
if (hero != undefined) {
ChakraArmorOnItemPickedUp(hero, event.itemname);
}
}
}
OnEntityHurt(event: EntityHurtEvent) {
const killed = EntIndexToHScript(event.entindex_killed)
if (killed?.IsBaseNPC() && killed.IsIllusion() && !killed.IsAlive()) {
killed.EmitSound("clone_pop");
}
}
OnPlayerPickHero(event: DotaPlayerPickHeroEvent) {
const player = EntIndexToHScript(event.player as EntityIndex);
if (!player?.IsPlayer()) {
return;
}
SetPlayerHealthLabel(player);
}
OnPlayerChat(event: PlayerChatEvent) {
if (event.text == "malubulul") {
malulubul(event.playerid);
}
}
OnPlayerGainedLevel(event: DotaPlayerGainedLevelEvent){
const player = PlayerResource.GetPlayer(event.player_id);
if(player){
const hero = player.GetAssignedHero();
const playerId = hero.GetPlayerOwnerID();
const longName = hero.GetUnitName();
const shortName = ShortHeroName(longName);
const innate_ability = hero.FindAbilityByName(`${shortName}_innate_passive`);
if(innate_ability){
innate_ability?.SetLevel(innate_ability.GetLevel() + 1)
}
}
}
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/temari/temari_great_wind_wall.ts
|
<gh_stars>0
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
@registerAbility()
export class temari_great_wind_wall extends BaseAbility {
Precache(context: CScriptPrecacheContext): void{
PrecacheResource("particle", "particles/units/heroes/temari/temari_great_wind_wlal.vpcf", context);
PrecacheResource("particle", "particles/units/heroes/temari/temari_great_wind_layer.vpcf", context);
PrecacheResource("soundfile", "soundevents/heroes/temari/game_sounds_temari.vsndevts", context);
//PrecacheResource("soundfile", "soundevents/heroes/temari/game_sounds_vo_temari.vsndevts", context);
}
/****************************************/
OnSpellStart(): void {
let caster = this.GetCaster();
let position = this.GetCursorPosition();
let radius = this.GetSpecialValueFor("radius");
let desired_angle = this.GetSpecialValueFor("angle") / 2;
let slow_duration = this.GetSpecialValueFor("slow_duration");
let knockback_distance = this.GetSpecialValueFor("knockback_distance");
let origin = caster.GetAbsOrigin();
let direction = (position - origin as Vector).Normalized();
let angle = VectorToAngles(direction).y;
let kv = {
center_x: origin.x,
center_y: origin.y,
center_z: origin.z,
should_stun: false,
duration: this.GetSpecialValueFor("knockback_duration"),
knockback_duration: this.GetSpecialValueFor("knockback_duration"),
knockback_distance: knockback_distance,
knockback_height: 0,
}
let damage_table: ApplyDamageOptions = {
attacker: caster,
victim: caster,
damage: this.GetSpecialValueFor("damage"),
damage_type: this.GetAbilityDamageType(),
ability: this
}
let enemies = FindUnitsInRadius(
caster.GetTeamNumber(),
origin,
undefined,
radius,
this.GetAbilityTargetTeam(),
this.GetAbilityTargetType(),
this.GetAbilityTargetFlags(),
FindOrder.ANY,
false
);
enemies.forEach(enemy => {
let relative_direction = (enemy.GetAbsOrigin() - origin as Vector).Normalized();
let relative_angle = VectorAngles(relative_direction).y;
let difference = math.abs(AngleDiff(angle, relative_angle));
if (difference <= desired_angle) {
enemy.RemoveModifierByName("modifier_knockback");
enemy.AddNewModifier(caster, this, "modifier_knockback", kv);
enemy.AddNewModifier(caster, this, "modifier_temari_great_wind_wall", {duration: slow_duration * (1 - enemy.GetStatusResistance())});
damage_table.victim = enemy;
ApplyDamage(damage_table);
}
});
EmitSoundOn("Hero_Temari.GreatWindWall.Cast", caster);
let effect_cast = ParticleManager.CreateParticle("particles/units/heroes/temari/temari_great_wind_wlal.vpcf", ParticleAttachment.CUSTOMORIGIN, caster)
ParticleManager.SetParticleControl(effect_cast, 0, origin)
ParticleManager.SetParticleControlForward(effect_cast, 0, direction)
ParticleManager.ReleaseParticleIndex(effect_cast)
ParticleManager.ReleaseParticleIndex(
ParticleManager.CreateParticle("particles/econ/items/windrunner/windranger_arcana/windranger_arcana_ambient_v2_ground_arcs_flat.vpcf", ParticleAttachment.ABSORIGIN, caster)
)
let dust_fx = ParticleManager.CreateParticle("particles/units/heroes/temari/temari_great_wind_layer.vpcf", ParticleAttachment.ABSORIGIN, caster);
ParticleManager.SetParticleControl(dust_fx, 1, origin)
ParticleManager.SetParticleControlForward(dust_fx, 1, -direction as Vector)
ParticleManager.SetParticleControlForward(dust_fx, 3, -direction as Vector)
ParticleManager.ReleaseParticleIndex(dust_fx);
}
}
@registerModifier()
export class modifier_temari_great_wind_wall extends BaseModifier
{
move_slow?: number;
/****************************************/
IsPurgable(): boolean {return true}
/****************************************/
OnCreated(params: Object): void {
this.move_slow = -this.GetAbility()!.GetSpecialValueFor("move_slow");
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.MOVESPEED_BONUS_PERCENTAGE
]}
/****************************************/
GetModifierMoveSpeedBonus_Percentage(): number {
return this.move_slow!;
}
/****************************************/
GetEffectName(): string {
return "particles/units/heroes/temari/temari_great_wind_wall_buff.vpcf";
}
/****************************************/
GetEffectAttachType(): ParticleAttachment {
return ParticleAttachment.ABSORIGIN;
}
}
|
jaden-young/NWR
|
src/vscripts/components/barebones/util.d.ts
|
/** @noSelfInFile */
export { };
declare global {
function DebugPrint(...args: any[]): void;
function DebugPrintTable(...args: any[]): void;
function PrintTable(...args: any[]): void;
/**
* Rolls a Psuedo Random chance. If failed, chances increases, otherwise chances are reset
* Numbers taken from https://gaming.stackexchange.com/a/290788
*/
function RollPseudoRandom(base_chance: number, entity: CDOTA_BaseNPC): boolean;
}
|
jaden-young/NWR
|
src/vscripts/abilities/heroes/sai/sai_innate_passive.ts
|
<reponame>jaden-young/NWR
import { BaseAbility, BaseModifier, registerAbility, registerModifier } from "../../../lib/dota_ts_adapter"
interface SaiInnateModifier extends CDOTA_Buff
{
UpdateValues(): void;
}
@registerAbility()
export class sai_innate_passive extends BaseAbility
{
GetIntrinsicModifierName(): string {
return "modifier_sai_innate_passive"
}
/****************************************/
Spawn(): void {
if (IsServer()) {
this.SetLevel(1);
}
}
/****************************************/
OnHeroLevelUp(): void {
(this.GetCaster().FindModifierByName("modifier_sai_innate_passive") as SaiInnateModifier).UpdateValues()
}
/****************************************/
ApplyDebuff(target: CDOTA_BaseNPC): void {
target.AddNewModifier(this.GetCaster(), this, "modifier_sai_innate_passive_debuff", {duration: this.GetSpecialValueFor("duration") * (1 - target.GetStatusResistance())});
}
}
@registerModifier()
export class modifier_sai_innate_passive extends BaseModifier
{
damage_amp?: number;
damage_amp_lvl?: number;
current_damage_amp?: number;
/****************************************/
IsPurgable(): boolean {return false}
RemoveOnDeath(): boolean {return false}
/****************************************/
OnCreated(params: object): void {
let ability = this.GetAbility()!;
this.damage_amp = ability.GetSpecialValueFor("damage_amp");
this.damage_amp_lvl = ability.GetSpecialValueFor("damage_amp_lvl");
this.current_damage_amp = this.damage_amp;
this.SetHasCustomTransmitterData(true);
if (!IsServer()) return;
this.StartIntervalThink(1);
}
/****************************************/
OnIntervalThink(): void {
this.UpdateValues();
}
/****************************************/
AddCustomTransmitterData() {
return {current_damage_amp: this.current_damage_amp}
}
/****************************************/
HandleCustomTransmitterData(data: any) {
this.current_damage_amp = data.current_damage_amp;
}
/****************************************/
UpdateValues(): void {
let parent = this.GetParent();
let level = parent.GetLevel() - 1;
this.current_damage_amp = this.damage_amp! + this.damage_amp_lvl! * level;
this.SendBuffRefreshToClients();
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.TOOLTIP
]}
/****************************************/
OnTooltip(): number {
return this.current_damage_amp!;
}
}
@registerModifier()
export class modifier_sai_innate_passive_debuff extends BaseModifier
{
damage_amp?: number;
/****************************************/
OnCreated(params: object): void {
let caster = this.GetCaster();
let ability = this.GetAbility();
let level = caster!.GetLevel() - 1;
this.damage_amp = ability!.GetSpecialValueFor("damage_amp") + ability!.GetSpecialValueFor("damage_amp_lvl") * level;
}
/****************************************/
OnRefresh(params: object): void {
this.OnCreated(params);
}
/****************************************/
DeclareFunctions(){ return [
ModifierFunction.INCOMING_DAMAGE_PERCENTAGE
]}
/****************************************/
GetModifierIncomingDamage_Percentage(): number {
return this.damage_amp!;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.