text:
This gem provides a binary that cat's syntax colorized code to the console.

## Installation

Add this line to your application's Gemfile:

    gem 'rcat'

And then execute:

    $ bundle

Or install it yourself as:

    $ gem install rcat

## Usage

For now it doesn't have any options, all you can do is colorize a list of files to console:

		% rcat file list goes here.rb

## Contributing

1. Fork it
2. Create your feature branch (`git checkout -b my-new-feature`)
3. Commit your changes (`git commit -am 'Add some feature'`)
4. Push to the branch (`git push origin my-new-feature`)
5. Create new Pull Request


text:
package edu.wsu.weather.agweathernet.helpers;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.net.Uri;
import android.os.Bundle;
import android.support.v4.app.FragmentManager;
import android.support.v4.app.FragmentTransaction;
import android.text.Html;
import android.view.LayoutInflater;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.TextView;
import edu.wsu.weather.agweathernet.R;
import edu.wsu.weather.agweathernet.fragments.AWNNewsItem;
import edu.wsu.weather.agweathernet.helpers.models.NewsEntry;

public class NewsAdapter extends BaseAdapter {

	Context ctx;
	List<NewsEntry> newsList;
	FragmentManager fm;
	String entryType;
	Activity activity;

	public NewsAdapter(Activity activity, Context ctx,
			List<NewsEntry> newsList, FragmentManager fm, String entryType) {
		this.ctx = ctx;
		this.newsList = newsList;
		this.fm = fm;
		this.entryType = entryType;
		this.activity = activity;
	}

	public void update(ArrayList<NewsEntry> newsList) {
		this.newsList = newsList;
		notifyDataSetChanged();
	}

	@Override
	public int getCount() {
		if (newsList == null)
			return 0;
		return newsList.size();
	}

	@Override
	public Object getItem(int index) {
		if (newsList == null)
			return null;
		return newsList.get(index);
	}

	@Override
	public long getItemId(int i) {
		return (long) i;
	}

	@SuppressLint("SimpleDateFormat")
	@Override
	public View getView(final int position, View convertView, ViewGroup parent) {
		View view = convertView;

		final NewsEntry newsModel = newsList.get(position);
		LayoutInflater inflater = (LayoutInflater) ctx
				.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

		if (view == null) {
			view = inflater.inflate(R.layout.news_list_row, parent, false);
		}

		TextView title = (TextView) view.findViewById(R.id.newsTitle);
		TextView pubDate = (TextView) view.findViewById(R.id.newsPubDate);
		TextView desc = (TextView) view.findViewById(R.id.newsDesc);

		title.setText(newsModel.getTitle());
		SimpleDateFormat formatter = new SimpleDateFormat(
				"yyyy-MM-dd hh:mm:ss");//2014-10-17 14:13:26
		// "EEE, dd MMM yyyy HH:mm:ss z");
		Date dateStr = new Date();
		try {
			dateStr = formatter.parse(newsModel.getPubDate());
			pubDate.setText(new SimpleDateFormat("MMM dd, yyyy")
					.format(dateStr).toString());
		} catch (ParseException e) {
			pubDate.setText(newsModel.getPubDate());
		}
		String descTxt = newsModel.getDescription();
		if (descTxt != null && descTxt.length() > 190) {
			descTxt = descTxt.substring(0, 190);
		}
		desc.setText(Html.fromHtml(descTxt));

		view.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View argView) {
				if (!newsModel.getLink().contains("weather.wsu.edu")
						&& newsModel.getLink().contains("http")) {
					Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri
							.parse(newsModel.getLink()));
					activity.startActivity(browserIntent);
				} else {
					AWNNewsItem newFrag = new AWNNewsItem();
					Bundle args = new Bundle();
					args.putString("link", newsModel.getLink());
					args.putString("entry_type", entryType);
					String pathToAdd = newsModel.getFolder();
					if (!pathToAdd.endsWith("/")) {
						pathToAdd += "/";
					}
					pathToAdd += newsModel.getFilename();
					args.putString("entry_file_path", pathToAdd);
					newFrag.setArguments(args);
					FragmentTransaction transaction = fm.beginTransaction();
					transaction.replace(R.id.container, newFrag);
					transaction.addToBackStack(null);
					transaction.commit();
				}
			}
		});

		return view;
	}

	@Override
	public boolean isEmpty() {
		return newsList.isEmpty();
	}
}

redpajama_set_name: RedPajamaGithub


text:
#import <AddressBook/ABPredicate.h>

@interface ABAnyValuePredicate : ABPredicate
{
    int _property;
}

@property(nonatomic) int property; // @synthesize property=_property;
- (void)ab_bindStatement:(struct CPSqliteStatement *)arg1 withBindingOffset:(int *)arg2 predicateIdentifier:(int)arg3;
- (id)queryWhereString;
- (id)queryGroupByProperties;
- (id)queryJoinsInCompound:(_Bool)arg1;
- (_Bool)isValid;
- (id)init;

@end


text:
"use strict";

const LikeHelper = require( "chai-like" );
const Session = require( "pegjs" ).compiler.Session;

module.exports = function ( chai, utils ) {

    chai.use( LikeHelper );

    const Assertion = chai.Assertion;

    function parse( grammar, session, options ) {

        const ast = session.parse( grammar );

        if ( ! options.allowedStartRules ) {

            options.allowedStartRules = ast.rules.length > 0
                ? [ ast.rules[ 0 ].name ]
                : [];

        }

        return ast;

    }

    Assertion.addMethod( "changeAST", function ( grammar, props, options, additionalRuleProps ) {

        options = typeof options !== "undefined" ? options : {};
        additionalRuleProps = typeof additionalRuleProps !== "undefined" ? additionalRuleProps : { reportFailures: true };

        const session = new Session( { grammar } );
        const ast = parse( grammar, session, options );

        ast.rules = ast.rules.map( rule => Object.assign( rule, additionalRuleProps ) );

        utils.flag( this, "object" )( ast, session, options );

        new Assertion( ast ).like( props );

    } );

    Assertion.addMethod( "reportError", function ( grammar, props, options ) {

        options = typeof options !== "undefined" ? options : {};

        const session = new Session( { grammar } );
        const ast = parse( grammar, session, options );

        let passed, result;

        try {

            utils.flag( this, "object" )( ast, session, options );
            passed = true;

        } catch ( e ) {

            result = e;
            passed = false;

        }

        this.assert(
            ! passed,
            "expected #{this} to report an error but it didn't",
            "expected #{this} to not report an error but #{act} was reported",
            null,
            result,
        );

        if ( ! passed && typeof props !== "undefined" ) {

            if ( typeof props === "string" ) props = { message: props };

            Object.keys( props ).forEach( key => {

                new Assertion( result )
                    .to.have.property( key )
                    .that.is.deep.equal( props[ key ] );

            } );

        }

    } );

    Assertion.addMethod( "reportWarning", function ( grammar, warnings, options ) {

        warnings = Array.isArray( warnings )
            ? warnings
            : warnings == null
                ? []
                : [ warnings ];

        options = typeof options !== "undefined" ? options : {};

        const messages = [];
        function warn( message ) {

            messages.push( message );

        }

        const session = new Session( { grammar, warn } );
        const ast = parse( grammar, session, options );

        utils.flag( this, "object" )( ast, session, options );

        const messagesCount = messages.length;
        const warningsCount = warnings.length;

        if ( warnings.length )

            this.assert(
                messagesCount === warningsCount,
                `expected #{this} to report ${ warningsCount } warnings, but it reported ${ messagesCount } warnings`,
                `expected #{this} to not report ${ warningsCount } warnings`,
                warnings,
                messages,
            );

        warnings.forEach( warning => {

            this.assert(
                messages.indexOf( warning ) !== -1,
                "expected #{this} to report the warning #{exp}, but it didn't",
                "expected #{this} to not report the warning #{exp}",
                warning,
            );

        } );

    } );

};


text:
/*globals YUI */
YUI.add('functional-test-case', function (Y) {

    //an abstract async runner class
    function AbstractRunner() {
    }

    AbstractRunner.prototype = {
        /**
         * runs asynchronously in scope `scope` calling the callback when done
         * @param scope the scope to use for running functions
         * @param callback the callback to call with an optional error when done.
         */
        execute: function (scope, callback) { throw new Error('AbstractRunner:execute - must be implemented'); },
        /**
         * returns the worst-case running time of this runner in milliseconds
         */
        getRuntimeMillis: function () { return 0; }
    };

    // expects a function with arity 0 or 1. When 1, the function is assumed to be async
    // and returned as-is. When 0, the function is assumed to be synchronous and a wrapper function is returned
    // that calls the sync function in its own scope, converting thrown exceptions to async errors.
    function maybeWrap(fn) {
        var deferred = function (callback, ex) {
            Y.later(0, null, callback, [ ex ]);
        };
        if (!(fn && typeof fn === 'function')) {
            throw new Error('Expected a function, found:' + fn);
        }
        if (fn.length > 1) {
            throw new Error('Function :' + fn + ' had arity > 1');
        }
        if (fn.length === 0) {
            return function (callback) {
                try {
                    fn.apply(this);
                    return deferred(callback);
                } catch (ex) {
                    return deferred(callback, ex);
                }
            };
        }
        return function (callback) {
            var tick = true;
            try {
                fn.apply(this, [function (ex) {
                    if (tick) {
                        return deferred(callback, ex);
                    }
                    return callback(ex);
                }]);
                tick = false;
            } catch (ex) {
                return deferred(callback, ex);
            }
        };
    }

    /**
     * Runner that runs a single function
     * @param fn the function to run
     * @param runtimeMillis the expected worst-case runtime in milliseconds for this function
     * @constructor
     */
    function FunctionRunner(fn, runtimeMillis) {
        FunctionRunner.superclass.constructor.call(this);
        this.fn = maybeWrap(fn);
        this.runtimeMillis = runtimeMillis || 10;
    }

    Y.extend(FunctionRunner, AbstractRunner, {
        /**
         * implements `run` by calling the function in correct scope
         */
        execute: function (scope, callback) {
            if (!callback && typeof scope === 'function') {
                callback = scope;
                scope = this;
            }
            return this.fn.call(scope, callback);
        },
        /**
         * returns the worst-case runtime by replaying the constructor arg
         */
        getRuntimeMillis: function () {
            return this.runtimeMillis;
        }
    });
    /**
     * Runner that runs a bunch of AbstractRunner objects in series
     * @param {Object} defaults - default configuration. Optional.
     * @param {number} defaults.timeout - the default timeout in milliseconds for waits
     * @param {number} defaults.shortWait - the default time in milliseconds to wait after mouse clicks etc.
     * @param {number} defaults.poll - the polling interval in milliseconds for tests with wait
     * @constructor
     */
    function Batch(defaults) {
        Batch.superclass.constructor.call(this);
        defaults = defaults || {};
        this.fns = [];
        this.defaults = {
            timeout: defaults.timeout || 10000,
            shortWait: defaults.shortWait || 100,
            poll: defaults.poll || 200
        };
    }

    Y.extend(Batch, AbstractRunner, {
        /**
         * implements `execute` by calling each of its runners in series
         */
        execute: function (scope, callback) {
            var i = -1,
                iteratorCallback,
                fns = this.fns,
                cb = function (err) {
                    if (err) { return callback(err); }
                    i += 1;
                    if (i >= fns.length) {
                        return callback();
                    }
                    return fns[i].execute(scope, iteratorCallback);
                };
            iteratorCallback = cb;
            if (!callback && typeof scope === 'function') {
                callback = scope;
                scope = this;
            }
            cb();
        },
        /**
         * returns the worst-case runtime as a sum of the worst-case runtimes of its children
         */
        getRuntimeMillis: function () {
            var i,
                total = 0;
            for (i = 0; i < this.fns.length; i += 1) {
                total += this.fns[i].getRuntimeMillis();
            }
            return total;
        },
        /**
         * Adds a function or another abstract runner to the list of children, returning `this`
         * so that calls can be chained
         * @param fn the function or AbstractRunner object to add to the children list
         * @param millis the worst case runtime of the function in milliseconds. This argument
         *  is ignored when adding an AbstractRunner instance
         * @returns `this`
         */
        add: function (fn, millis) {
            if (fn instanceof AbstractRunner) {
                this.fns.push(fn);
            } else {
                this.fns.push(new FunctionRunner(fn, millis));
            }
            return this; //make chainable
        },
        /**
         * creates another batch object using the defaults used for this one, unless specifically overridden.
         * Note that there is no other relationship between the objects. If you want to create a
         * batch that is the child of this one, you need to explicitly `add` it
         * @param {Object} defaults - default configuration for the batch created. Optional.
         * @returns {Batch} a Batch object with merged defaults.
         */
        createBatch: function (defaults) {
            return new Batch(Y.merge(this.defaults, defaults || {}));
        }
    });

    /**
     * extends the `Batch` prototype using the supplied generator
     * @param name the method name to add to the prototype
     * @param generator a function that takes any number of arguments and returns a function
     *  or an AbstractRunner that is then added to this batch's children
     */
    Batch.extend = function (name, generator) {
        if (Batch.prototype.hasOwnProperty(name)) {
            throw new Error('Attempt to extend the Batch prototype for an existing method: ' + name);
        }
        if (!(generator && typeof generator === 'function')) {
            throw new Error('Generator for name [' + name + '] must be a function');
        }
        Batch.prototype[name] = function () {
            var args = Array.prototype.slice.call(arguments),
                fn = generator.apply(this, args);
            return this.add(fn);
        };
    };

    Batch.extend('wait', function (millis) {
        millis = millis || this.defaults.timeout;
        return new FunctionRunner(function (cb) {
            Y.later(millis, null, cb);
        }, millis);
    });

    Batch.extend('waitUntil', function (testFn, timeout, pollInterval, timeoutMsg) {
        var timePassed = 0,
            shortWait = this.defaults.shortWait,
            timer,
            endFn = function (cb, err) {
                if (timer) { timer.cancel(); }
                Y.later(shortWait, null, function () { return cb(err); });
            },
            pollFn = function (cb) {
                try {
                    if (testFn()) {
                        return endFn(cb);
                    }
                    timePassed += pollInterval;
                    if (timePassed > timeout) {
                        return endFn(cb, new Error(timeoutMsg || 'Test function did not return true in the allotted time'));
                    }
                } catch (ex) {
                    return endFn(cb, ex);
                }
            };

        if (typeof testFn !== 'function') { throw new Error('waitUntil: Need a test function to execute, found ' + testFn); }
        timeout = timeout || this.defaults.timeout;
        pollInterval = pollInterval || this.defaults.poll;

        return new FunctionRunner(function (cb) {
            timer = Y.later(pollInterval, null, pollFn, cb, true);
        }, timeout);
    });

    function isVisible(node) {
        var domNode = Y.Node.getDOMNode(node);
        if (!domNode) {
            return false;
        }
        return Y.DOM.getComputedStyle(domNode, 'display') !== 'none' && Y.DOM.getComputedStyle(domNode, 'visibility') !== 'hidden';
    }

    Batch.extend('debug', function (str) {
        return function () {
            Y.log(str);
        };
    });

    Batch.extend('waitForElement', function (selector, timeout, pollInterval) {
        var fn = function () {
            var node = Y.one(selector);
            return node && isVisible(node);
        };
        return this.createBatch().waitUntil(fn, timeout, pollInterval, 'Could not find node [' + selector + '] in the allotted time');
    });

    Batch.extend('click', function (selector) {
        return this.createBatch()
            .add(function () {
                var node = Y.one(selector);
                if (!node) { throw new Error('Unable to find node with selector: ' + selector); }
                try {
                    node.simulate('mousedown');
                    node.simulate('mouseup');
                    node.simulate('click');
                } catch (ex) {} //swallow
            })
            .wait(this.defaults.shortWait);
    });

    Batch.extend('setValue', function (selector, value) {
        return this.createBatch()
            .add(function () {
                var node = Y.one(selector);
                if (!node) { throw new Error('Unable to find node with selector: ' + selector); }
                //make this more fancy to detect input type and set value appropriately
                try {
                    node.simulate('focus');
                } catch (ex) {} //swallow
                node.set('value', value);
                //trigger any events associated with key presses
                try {
                    node.simulate('keydown', { keyCode: 32 });
                    node.simulate('keyup', { keyCode: 32 });
                    node.simulate('keypress', { charCode: 32 });
                } catch (ex2) {}
            })
            .wait(this.defaults.shortWait);
    });

    Batch.extend('waitAndClick', function (selector, timeout) {
        return this.createBatch()
            .waitForElement(selector, timeout)
            .click(selector);
    });
    /**
     * A top-level batch that is associated with a test and has a `run` method
     * @param test the test to which this batch is associated
     * @param defaults - the default batch configuration
     * @constructor
     */
    function TestBatch(test, defaults) {
        this.test = test;
        TestBatch.superclass.constructor.call(this, defaults);
    }

    Y.extend(TestBatch, Batch, {
        /**
         * runs this batch asynchronously using the `wait` and `resume` methods of its
         * associated test.
         */
        run: function () {
            var test = this.test,
                timeout = this.getRuntimeMillis(),
                callback = function (err) {
                    test.resume(function () {
                        if (err) {
                            var msg = err.message || String(err);
                            if (typeof err === 'object') {
                                if (err.hasOwnProperty('expected')) {
                                    msg += '\nExpected: ' + err.expected + ' (' + typeof err.expected + ')';
                                }
                                if (err.hasOwnProperty('actual')) {
                                    msg += '\nActual: ' + err.actual + ' (' + typeof err.actual + ')';
                                }
                            }
                            Y.Assert.fail(msg);
                        }
                    });
                };

            this.execute(test, callback);
            test.wait(timeout);
        }
    });

    var FCase = Y.Test.FunctionalTestCase = function () {
        FCase.superclass.constructor.apply(this, arguments);
    };

    FCase.Batch = Batch;

    Y.extend(FCase, Y.Test.Case, {
        /**
         * returns a batch that can be run for the test
         * @param defaults
         * @returns {TestBatch}
         */
        batch: function (defaults) {
            return new TestBatch(this, defaults);
        }
    });

}, "0.1", { requires: [ "test", "dom", "node", "node-event-simulate" ]});


text:
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.heliosmi</groupId>
	<artifactId>project-euler-solutions</artifactId>
	<version>0.1</version>
	<packaging>jar</packaging>
	<name>Project Euler Solutions</name>
	<url>http://www.springframework.org</url>
	<properties>
		<maven.test.failure.ignore>true</maven.test.failure.ignore>
		<spring.framework.version>3.2.4.RELEASE</spring.framework.version>
		<org.aspectj-version>1.7.3</org.aspectj-version>
		<org.slf4j-version>1.7.5</org.slf4j-version>
	</properties>
	<dependencies>
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>4.11</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring.framework.version}</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.framework.version}</version>
		</dependency>

		<!-- AspectJ -->
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>${org.aspectj-version}</version>
		</dependency>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>${org.aspectj-version}</version>
		</dependency>

		<!-- Logging -->
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-api</artifactId>
			<version>${org.slf4j-version}</version>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>jcl-over-slf4j</artifactId>
			<version>${org.slf4j-version}</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.slf4j</groupId>
			<artifactId>slf4j-log4j12</artifactId>
			<version>${org.slf4j-version}</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>log4j</groupId>
			<artifactId>log4j</artifactId>
			<version>1.2.17</version>
		</dependency>

		<!-- commons lang -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-lang3</artifactId>
			<version>3.1</version>
		</dependency>

	</dependencies>

	<build>
		<pluginManagement>
			<plugins>
				<plugin>
					<groupId>org.apache.maven.plugins</groupId>
					<artifactId>maven-compiler-plugin</artifactId>
					<version>3.1</version>
					<configuration>
						<source>1.7</source>
						<target>1.7</target>
					</configuration>
				</plugin>
			</plugins>
		</pluginManagement>
	</build>
	<description>Project Euler Solutions</description>
</project>


text:
package io.pebbletemplates.pebble.node.expression;

import io.pebbletemplates.pebble.error.PebbleException;
import io.pebbletemplates.pebble.node.RenderableNode;
import io.pebbletemplates.pebble.template.EvaluationContextImpl;
import io.pebbletemplates.pebble.template.PebbleTemplateImpl;
import io.pebbletemplates.pebble.utils.LimitedSizeWriter;

import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;

/**
 * This class wraps a {@link RenderableNode} into an expression. This is used by the filter TAG to
 * apply a filter to large chunk of template which is contained within a renderable node.
 *
 * @author mbosecke
 */
public class RenderableNodeExpression extends UnaryExpression {

  private final RenderableNode node;

  private final int lineNumber;

  public RenderableNodeExpression(RenderableNode node, int lineNumber) {
    this.node = node;
    this.lineNumber = lineNumber;
  }

  @Override
  public Object evaluate(PebbleTemplateImpl self, EvaluationContextImpl context) {
    Writer writer = LimitedSizeWriter.from(new StringWriter(), context);
    try {
      this.node.render(self, writer, context);
    } catch (IOException e) {
      throw new PebbleException(e, "Error occurred while rendering node", this.getLineNumber(),
          self.getName());
    }
    return writer.toString();
  }

  @Override
  public int getLineNumber() {
    return this.lineNumber;
  }

}


text:
'use strict'

const assert = require('assert')
const sinon = require('sinon')
const EventEmitter = require('events')
const LoggerInterface = require(__source + 'logger/logger-interface')
const SigtermListener = require(__source + 'launcher/sigterm-listener')

class Logger extends LoggerInterface {}

describe('sigterm-listener', () => {
  beforeEach(() => {
    this.sandbox = sinon.sandbox.create()

    this.emitter = new EventEmitter()
    this.logger = new Logger()
    this.sigtermListener = new SigtermListener(this.emitter, this.logger)
  })

  afterEach(() => {
    this.sandbox.restore()
  })

  it('.listen() should attach listener to SIGTERM process event', () => {
    var loggerWarnStub = this.sandbox.stub(this.logger, 'warn')
    var listenerStub = this.sandbox.stub()

    this.sigtermListener.listen(listenerStub)
    this.emitter.emit('SIGTERM')

    assert.ok(loggerWarnStub.calledOnce)
    assert.ok(listenerStub.calledOnce)
  })
})


text:
<!DOCTYPE html>
<html>
    <head>
        <meta charset="utf-8">
        <title>Isomorphic demo app</title>
    </head>
    <body>

        <script type="text/javascript" src="build/bundle.js"></script>

    </body>
</html>


text:
package model.powers.impl;

import java.awt.image.BufferedImage;

import model.powers.Power;
import model.powers.PowerID;
import controller.GameController;

/**
 * Fire a bullet that annihilate other snow balls (powered included)
 *
 * @author Simar Jérémy
 *
 */
public class OneShotPower extends Power {

	public static BufferedImage oneShotImage;

	public int from_x;
	public int y;

	public OneShotPower() {
		super(PowerID.OneShot);
	}

	@Override
	public void onClickAction() {
		GameController.shotFire(this);
	}

}